inteligencia de plataforma para el desarrollo de juegos por

ESCUELA TÉCNICA SUPERIOR DE INGENIERÍA (ICAI)
INGENIERO EN INFORMÁTICA
INTELIGENCIA DE PLATAFORMA PARA
EL DESARROLLO DE JUEGOS POR
COMPUTADOR
Autor: Antonio Jesús Berbel Rodríguez-Campra
Directores: Álvaro Arranz Domingo
Manuel Alvar Miró
Madrid
Septiembre 2012
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
Agradecimientos
En primer lugar, agradecer la finalización de este proyecto a mi madre que,
aunque ya sepa lo mucho que la aprecio, pero quiero que sirvan estas palabras
para expresarle mi absoluta admiración y gratitud por el apoyo que me ha
prestado a lo largo de lo que ha sido mi vida académica.
A los profesores que me han impartido clase en las diferentes carreras que
he cursado en esta Universidad ya no sólo por los conocimientos técnicos que me
han enseñado sino por los valores humanos y profesionales que han sabido
inculcarme. En especial quiero agradecer a Álvaro Sánchez Miralles, Álvaro Arranz
Domingo y Manuel Alvar Miró por la oportunidad que me han brindado con la
realización de este proyecto y por haber confiado siempre en mí.
Y en último lugar pero no menos importante a mis compañeros de clase
durante todos estos años en ICAI, en especial a Alberto Rodríguez Gómez y Alberto
Gutierrez García porque sin ellos no hubiese sido lo mismo. Me voy feliz de poder
contar con su amistad ahora y en tiempos venideros.
I
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
INTELIGENCIA DE PLATAFORMA PARA EL DESARROLLO DE
JUEGOS POR COMPUTADOR
Autor: Berbel Rodríguez-Campra, Antonio Jesús.
Directores: Arranz Domingo, Álvaro.
Alvar Miró, Manuel.
Entidad Colaboradora: ICAI – Universidad Pontificia Comillas.
RESUMEN DEL PROYECTO
El proyecto consiste en el modelado, desarrollo de un módulo para una Plataforma
de juegos multijugador que sea capaz de interpretar los distintos elementos y reglas de los
juegos que sean desarrollados para ésta y que pueda simular una partida entre varios
jugadores y el desarrollo del juego de mesa Risk para esta plataforma.
Para ello la aplicación es capaz de leer los ficheros donde se le indican las reglas del juego y
la descripción de las entidades que participan en éste e interpretarlos para ser capaz de
aplicarlas durante el desarrollo de una partida entre diferentes oponentes.
1 ESTADO DEL ARTE
La idea de que las computadoras pudiesen jugar contra un contrincante humano
existe desde la creación de éstas. Babbage, conocido como “El padre de la computación”
[GuiV10], ya trató de programar su máquina analítica para que jugara al ajedrez pero debido
a la falta de financiación nunca llegó a terminarla y solo consiguió terminar un diseño
plenamente funcional.
Los juegos en comparación con otras aplicaciones de inteligencia artificial no
necesitan grandes cantidades de conocimiento por lo que en un primer momento se pensó
que se podrían resolver por búsqueda exhaustiva en el
árbol de juego. Considerando como ejemplo el ajedrez, la
cantidad de movimientos que el ordenador debe evaluar,
no solo lo suyos sino también los de su contrincante,
genera un elevado coste computacional por lo que es
necesario algún tipo de procedimiento de búsqueda
heurística.
En nuestro país, el ocio digital supera ampliamente al cine y la música juntos en
ingresos. Según un estudio de la consultora Ibis Capital los videojuegos han logrado
II
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
colocarse en todo el mundo prácticamente a la altura de toda la maquinaria global de
Hollywood, juntando la recaudación en cines y ventas en DVD.
Debido a este avance de la industria del ocio digital se ha visto una necesidad de
desarrollar una aplicación sencilla para el usuario con la que pueda desarrollar sus propios
juegos y poder compartirlos con otros jugadores.
Actualmente
existen diferentes herramientas que
facilitan el desarrollo de juegos basados en motores gráficos ya
desarrollados. Una de estas herramientas es UnrealEngine
[UNRE12] implementado inicialmente para el shotter en primera
personal Unreal. Fue desarrollado por la compañía EpicGames
y es compatible en diversas plataformas como PC, Apple
Macintosh y la mayoría de las consolas. Actualmente es considerada una de las
herramientas para el desarrollo de juegos más potentes que existen en la actualidad. Este
motor está orientado a juegos en primera persona y es de licencia propietaria por lo que
limita mucho su uso para poder utilizarlo en juegos amateur.
El motor Unity es otro motor para el desarrollo de videojuegos en 3D. Una de las
mayores diferencias con respecto al motor Unreal es que puede utilizarse para el desarrollo
de juegos por navegador y móviles ampliando enormemente el número de plataformas
sobre el que puede utilizarse.
Existe también un proyecto ideado por BarneyPell con el que pretendía crear un
programa que sirviese para poder jugar diferentes juegos a partir de unas reglas que el
programa interpretaría y aprendería a jugar [PELL92]. Aparte, la aplicación era capaz de
generar automáticamente nuevas reglas en base a las aprendidas anteriormente creando un
nuevo juego comprensible y jugable. El programa fue desarrollado en Prolog por lo que era
muy útil para explorar y experimentar con Metajuegos pero insuficiente para escribir juegos
de una mayor complejidad.
En este proyecto se desarrollará una aplicación capaz de interpretar las reglas de un
juego de mesa por turnos para partidas multijugador tanto con jugadores humanos como
jugadores manejados por la máquina. Las reglas del juego se podrán modificar sin
necesidad de recompilar todo el código desarrollado permitiendo la creación de nuevos
juegos.
III
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
3 DESARROLLO
Análisis
Durante la etapa del análisis de la aplicación, se estudió la forma de plantear las
reglas del juego y entidades de éste.Esta primera etapa consistió en el modelado de la
forma, estructura y reglas de los juegos de mesa en general. El objetivo era conseguir que el
desarrollador se guiase por este modelo a la hora de crear juegos y que el módulo de
Inteligencia Artificial pudiese leer esta información a partir de unos ficheros creados por los
usuarios que contuviesen toda la información necesaria del juego de una forma sencilla e
intuitiva. Otro factor importante era conseguir que la lectura de estos ficheros no implicase
la recompilación de la aplicación. Se decidió utilizar el lenguaje XML y el lenguaje de
script Python para escribir esta información ya que es un lenguaje sencillo de utilizar y no
es necesario compilar el código para cada juego. Para recabar toda esta información en un
único sitio se desarrolló el Kernel de la aplicación que sería el encargado de procesar todos
estos datos y gestionar las diferentes llamadas a las funciones Python.
El siguiente paso consistió en describir e implementar un juego de mesa utilizando
XML. Se decidió usar el juego de mesa Risk ya que era un juego conocido por todos los
participantes en el proyecto y muy extendido. Se desarrollaron los ficheros que contenían
las entidades del juego que se dividieron en: Recursos, Unidades, Estructuras y Eventos.
Para la información del juego se crearon dos ficheros XML: Estados del juego e
Información del juego.
A continuación se describieron las diferentes clases que formarían la lógica de
objetos mediante un modelo lógico. Utilizando la herramienta de IBM SDP que permite
convertir el Modelo lógico a clases en C++.
Desarrollo
Para el desarrollo del Kernelde la aplicación, uno de los elementos fundamentales,
se crearon tres grandes bloques. El primer bloque, Lectura XML, se crearía el módulo
encargado de leer los ficheros XML. En el segundo bloque se crearía el módulo Manejador
de estados que sería el encargado de decidir el curso del juego para la Inteligencia de
jugadores no humanos. Por último el tercer bloque sería el encargado de definir las
funciones internas de la aplicación y ejecutar las funciones externas a la aplicación que
tendrían acceso a las funciones internas.
Durante la primera etapa se desarrolló el módulo de Lectura de los ficheros XML.
Se eligió este lenguaje ya que se trata de un metalenguaje extensible de etiquetado muy útil
IV
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
para el intercambio de información en aplicaciones estructuradas. Para conseguir esto se
decidió utilizar la librería TinyXML[TINY12] ya que facilitaba su desarrollo.
En la segunda etapa se desarrolló el Manejador de Estados. Su función es la de tener
almacenada la información de los diferentes estados por los que puede transcurrir un juego
y conocer los diferentes saltos de un estado a otro.
A continuación se desarrollaron las funciones internas del juego. Su propósito es el
de simplificar la comunicación entre las funciones externas desarrolladas por los usuarios
de la plataforma y el núcleo de la aplicación.
Para el desarrollo de las funciones externas se estudiaron varios lenguajes de script.
Se decidió utilizar el lenguaje Python ya que se trata de un lenguaje de alto nivel que utiliza
una sintaxis limpia y legible. A parte, soporta la orientación a objetos, herencia múltiple,
polimorfismo y es un lenguaje multiplataforma. Para la comunicación entre la aplicación
desarrollada en C++ y las funciones externas se utilizó la librería boost [ BOOS12].
Por último se desarrolló el juego de mesa Risk para comprobar el buen
funcionamiento del motor. Se definieron las reglas y los diferentes elementos que
participaban en el juego y se realizaron pruebas utilizando este juego para comprobar
satisfactoriamente el buen funcionamiento del motor desarrollado.
4 REFERENCIAS
[PELL92]
[GUIJ10]
[TINY12]
[BOOS12]
[UNRE12]
Barney Pell. University of Cambridge. METAGAME: A New
Challenge for Games and Learning.
Victor Guijarro. La quimera del autómata matemático: del
calculador medieval a la máquina analítica de Babbage.
http://www.grinninglizard.com/tinyxml/
http://www.boost.org/
http://www.unrealengine.com/
V
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
INTELLIGENCE PLATFORM
COMPUTER GAMES
FOR
THE
DEVELOPMENT
OF
Author: Berbel Rodríguez-Campra, Antonio Jesús.
Supervisors: Arranz Domingo, Álvaro.
Alvar Miró, Manuel.
Affiliation: ICAI – Universidad Pontificia Comillas.
ABSTRACT
The goal of this project is developing a module for a multiplayer gaming platform to be able
to interpret the different elements and rules of the games that are developed for this and you
can simulate a game between multiple players.
This application should be able to read the files where you indicate the game and the
description of the entities involved in this and interprets them to be able to apply during the
course of a game between different opponents.
1 INTRODUCTION
Artificial Intelligence
According to Stuart Russell enunciated in 1995, "Artificial Intelligence is the
discipline that deals with the creation of computer programs that simulate the action and
human thought and rational behavior."
To better explain the above definition on Artificial Intelligence, understood to mean
an agent capable of receiving information about the surrounding environment, process it
and act on that environment tend to maximize the expected result.
There are different kinds of knowledge and means of representation of such
knowledge, which can be loaded into the agent designer or artificial intelligence, it can be
learned
by
using
learning
techniques.
Artificial Intelligence is applicable in different fields such as economics, medicine,
engineering
and
a
variety
of
software
applications.
Lately he has taken a considerable weight the use of artificial intelligence in virtual worlds
that simulate a world or artificial environment inspired or not in reality, in which users can
interact with characters or avatars
VI
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
2 STATE OF THE ART
The idea that computers could play against a human opponent has existed since the creation
thereof. Babbage, known as the "Father of computing" [GUIJ10], tried to set his analytical
engine to play chess but due to lack of funding never finish it and only managed to
complete a fully functional design.
The games compared to other artificial intelligence applications do not need large
amounts of knowledge so that at first it was thought that could be solved by exhaustive
search in the game tree. Considering the example of chess, the number of movements that
the computer must evaluate not only what his own but those of his opponent, resulting in a
high computational cost that is necessary for some form of heuristic search procedure.
In our country, the digital entertainment exceeds the movies and music together in
revenues. According to a study by consultancy Capital Ibis video games have been placed
in virtually every one at the height of the entire global machinery of Hollywood, joining the
collection in cinemas and DVD sales.
Due to the advancement of digital entertainment industry has seen a need to develop
a user-friendly application with which to develop their own games and to share them with
other players.
Currently there are different tools that facilitate the development of games based on
graphics engines already developed. One such tool is Unreal Engine [UNRE12] Shotter
initially implemented for the first Unreal staff. It was developed by Epic Games and it is
compatible on various platforms like PC, Apple Macintosh and most consoles. He is
currently considered one of the tools for game development more powerful than currently
exist. This engine is aimed at first-person games is proprietary license and therefore limits
their
use
to
use
in
amateur
games.
There is also a project designed by Barney Pell to pre-create a program that would
serve to play different games from the program rules that interpret and learn to play
[PELL92]. Besides, the application was able to automatically generate new rules based on
previously learned by creating a new game understandable and playable. The program was
developed in Prolog so it was very useful to explore and experiment with metagames but
not enough to write more complex games.
VII
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
This project will develop an application capable of interpreting the rules of a board
game for multiplayer turn-based human players as both players managed by the machine.
The game rules can be modified without recompiling all the code developed allowing the
creation of new games.
3 DEVELOPMENT
Analysis
During the stage of application development, we studied how to approach the game and
entities thereof. The aim was to make the AI module could read this information from some
files created by users all necessary information contais the game in a simple and intuitive.
Another important factor was to make the reading of these files did not involve recompiling
the application. We decided to use XML to write this information because a language is
easy to use and is not necessary to compile the code for each game.
The next step was to describe a board game using XML. It was decided to use the
board game Risk as it was a game known by all project participants and widespread. Files
were developed that contained the bodies of the game that were divided into: resources,
units, structures and events.
For game information created two XML files: State of play and game information.
Below are described the different classes of objects form logic by a logic model.
Using the IBMSDPtool for converting the logical model classes in C++.
Development
For application development, created three large blocks. The first block, reading XML, you
create the module responsible for reading XML files. In the second block Manager Module
creates the states would be responsible for deciding the course of the game for players
nonhuman intelligence. Finally the third group would be responsible for defining the
internal functions of the application and execute external functions to the application that
have access to internal functions.
During the first stage was developed in the form of reading XML files. Language
VIII
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
was chosen because it is an extensible meta tagging useful for exchanging structured
information in applications. To achieve this we decided to use the TinyXML
library[TINY12] and facilitating their development.
In the second step developed Handler States. Its function is to have stored he
information of the different states through which it can take a game and know the different
jumps from one state to another.
Then we developed internal functions of the game. Its purpose is to simplify
communication between the external functions developed by the users of the platform and
the application core.
For the development of the internal functions were studied several scripting
languages. We decided to use the Python language as it is a high-level language that uses a
clean and readable syntax. Besides, it supports object-orientation, multiple inheritance,
polymorphism, and is a multiplatform language. For communication between the
application developed in C++ and external functions are used the boost library [BOOS12].
4 REFERENCES
[PELL92]
[GUIJ10]
[TINY12]
[BOOS12]
[UNRE12]
Barney Pell. University of Cambridge. METAGAME: A New
Challenge for Games and Learning.
Victor Guijarro. La quimera del autómata matemático: del
calculador medieval a la máquina analítica de Babbage.
http://www.grinninglizard.com/tinyxml/
http://www.boost.org/
http://www.unrealengine.com/
IX
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
Índice de la memoria
1.
Introducción .....................................................................................................................1
1.1
Introducción .............................................................................................................. 2
1.2
Estado del Arte .......................................................................................................... 3
2.
Alcance del Proyecto ......................................................................................................15
2.1
Motivación .............................................................................................................. 16
2.2
Objetivos ................................................................................................................. 17
3.
Tecnologías.....................................................................................................................19
3.1
C++ .......................................................................................................................... 20
3.2
XML ......................................................................................................................... 21
3.3
Python ..................................................................................................................... 23
4.
Arquitectura ...................................................................................................................29
4.1
Arquitectura del Sistema ......................................................................................... 30
4.2
Módulo: Información del Juego ............................................................................... 33
4.3
Módulo: Reglas del Juego ........................................................................................ 35
4.4
Módulo: Kernel ........................................................................................................ 37
5.
Diseño del Sistema .........................................................................................................41
5.1
Introducción ............................................................................................................ 42
5.2
Diagrama de Secuencia ............................................................................................ 43
5.3
Diagrama de Flujo.................................................................................................... 45
5.4
Diagrama de Clases.................................................................................................. 46
6.
Risk .................................................................................................................................51
6.1
Introducción ............................................................................................................ 52
6.2
Elementos del Juego ................................................................................................ 53
6.3
Diseño del Risk ........................................................................................................ 61
7.
Planificación ...................................................................................................................65
8.
Estudio Económico .........................................................................................................69
X
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
9.
Conclusiones y trabajos futuros......................................................................................75
9.1
Conclusiones ........................................................................................................... 76
9.2
Trabajos Futuros ...................................................................................................... 78
10. Bibliografía .....................................................................................................................79
Anexo 1Manual de Instalación ...............................................................................................81
Anexo 2Manual de Usuario ....................................................................................................87
Anexo 3Manual de Desarrollador......................................................................................... 101
XI
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
1. Introducción
Escuela Técnica Superior de Ingeniería (ICAI)
Página 1
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
1.1 Introducción
El proyecto planteado busca proporcionar una solución a la dificultad siempre
latente del desarrollo rápido y sencillo de juegos para ordenador. El sistema que se ha
desarrollado es capaz de interpretar la información y las reglas de un juego de mesa por
turnos desarrollado en un lenguaje de programación de escasa dificultad para poder
simular una partida entre varios jugadores.
El usuario será por tanto capaz de desarrollar un juego sin llegar a necesitar unos
conocimientos elevados de programación y podrá compartirlo con otros usuarios que
hagan uso de esta herramienta. También podrá modificar juegos desarrollados por
terceros sin necesidad de conocer el funcionamiento interno del sistema de una forma
sencilla y escalable.
Gracias a la solidez de su arquitectura, se deja abierta la posibilidad de que el
sistema sea capaz de simular partidas entre múltiples jugadores por lo que pueda
definirse como una aplicación interactiva y de fácil manejo.
Para las pruebas realizadas a la herramienta se han desarrollado las reglas del
juego de mesa “Risk” debido a su popularidad.
Escuela Técnica Superior de Ingeniería (ICAI)
Página 2
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
1.2 Estado del Arte
Un videojuego es un software desarrollado para el entretenimiento en general
que está basado en la interacción entre una o varias personas y una máquina que
ejecutará dicho juego. Este dispositivo puede ser una computadora, una videoconsola o
incluso un teléfono móvil.
Los primeros videojuegos informáticos hacían uso de un teclado para interactuar
con la computadora. Los videojuegos modernos permiten utilizar tanto el teclado como
el ratón de forma simultánea.
En muchas ocasiones, los videojuegos recrean entornos o mundos virtuales en
los que el jugador es capaz de controlar uno o más personajes que interactúen con dicho
entorno para conseguir los objetivos marcados por el creador de juego respetando una
serie de reglas predeterminadas y conocidas.
Durante una partida, la interacción puede producirse entre una persona y una
máquina o entre dos o más personas que jueguen en la misma computadora o a través de
una red LAN o Internet compitiendo contra la máquina, con ella o entre ellos mismos.
1.2.1
Historia de los videojuegos
La industria de los videojuegos surgió con bastante fuerza en Estados Unidos,
Europa y Australia con la salida al mercado de Pong a principios de la década de los 70
y se extendió rápidamente por todo el mundo. Este videojuego fue publicado por Atari y
fue creado por NolanBushnell. Estaba basado en el deporte de tenis de mesa (ping
pong). Fue desarrollado en dos dimensiones y consistía en que el jugador controlaba
una paleta moviéndola verticalmente en la
parte izquierda de la pantalla. Podía
competir contra la misma computadora o
contra otro jugador humano que controlase
una segunda paleta en la parte opuesta. El
objetivo consistía en que uno de los
jugadores consiguiese más puntos que el
oponente al finalizar el juego.
Escuela Técnica Superior de Ingeniería (ICAI)
Página 3
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
Pese a que existieron con anterioridad otros videojuegos como OXO o el
Spacewar!, Pong está considerado como el más importante de entre la primera
generación de videojuegos modernos debido a que fue el primero en comercializarse a
nivel masivo y no ejecutarse en máquinas únicas.
Tras alcanzar un crecimiento espectacular, la industria japonesa comenzó a
perfeccionar y desarrollar la tecnología del videojuego introduciendo juegos tan
conocidos como el Super Mario Bros de NintendoCompany Ltd.
Durante la década de los 90, Nintendo y Sega realizaron importantes esfuerzos
por controlar y afianzar el mercado del videojuego. Durante esta época comenzaron a
surgir las críticas por el aumento de la violencia y la introducción de temas para adultos
en juegos infantiles.
Los videojuegos han tenido en ocasiones mala imagen en la sociedad originada
en muchas ocasiones por opiniones vertidas por los medios de comunicación aunque
últimamente este tipo de opiniones han ido mejorando. Según un estudio un niño
actualmente desarrolla habilidades mentales y su capacidad de razonamiento es más
activa en comparación con un niño de hace 20 años que no contaba con esta tecnología.
Por el contrario, la falta de socialización y algunos aspectos de su desarrollo motriz
pueden verse influenciados negativamente debido a las nuevas tecnologías. En cambio,
para los adultos los videojuegos han resultado ser un liberador de estrés.
1.2.2
Industria de los videojuegos
Es el sector económico involucrado en el desarrollo, distribución, mercadotecnia
y la venta de videojuegos y hardware asociado a éstos. Actualmente engloba a docenas
de disciplinas de trabajo y emplea a miles de personas alrededor
del mundo.
Actualmente,
la
industria
de
videojuegos
ha
experimentado unas altas tasas de crecimiento debido al
desarrollo de la computación, a la mejora en la capacidad de
procesamiento de imágenes más reales y a la cada vez más
estrecha relación entre películas de cine y los videojuegos. Los
videojuegos han pasado a generar más dinero que el cine y la
música juntos, como es el caso de España. Solo el ocio digital
acapara el 53 por ciento de las ventas de entretenimiento en los
Escuela Técnica Superior de Ingeniería (ICAI)
Página 4
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
hogares españoles dejando el resto a la música, el cine y el DVD. Esta industria generó
57.600 millones de euros durante 2009 en todo el mundo.
Ibis Capital calcula que actualmente la media de desarrollo por juegos se mueve
entre los 7,4 y los 9,7 millones de euros, por lo que destaca la importancia de apostar
por las franquicias consolidadas. Mario sigue a la cabeza del „ranking‟ de sagas más
vendidas, seguido por Pokémon, Tetris, Los Sims, NeedforSpeed y Final Fantasy.
Nintendo, EA, SquareEnix y TakeTwo son las compañías más populares.
Otra tendencia que destaca dicho estudio es la importancia que han ganado los
juegos online y para móviles que representan el 32 por ciento de los ingresos totales de
la industria. Los principales “culpables” de esta tendencia son Wii con su éxito entre los
jugadores casuales y su servicio WiiWare, Apple Store para iPhone y el juego online
World of Warcraft de la compañía Blizzard.
Según Ibis Capital, en el mercado de las consolas de sobremesa Nintendo
acapara el 47% de la cuota con la Wii, Xbox 360 posee un 35% y la PlayStation 3 un
18%.
Figura 2 – Wii, Xbox 360 y PS3
1.2.3
Videojuegos para PC
El mercado de videojuegos para computadoras personales ha ido en descenso
desplazado por las consolas. Este tipo de plataforma fue más popular en los noventa con
la aparición del CD-ROM.
Actualmente, el sector de los videojuegos de PC se mantiene principalmente por
las siguientes razones:
Mayor versatilidad: Existen a disposición de los jugadores lo necesario para la
creación de nuevos mapas e incluso han surgido las nuevas comunidades
Escuela Técnica Superior de Ingeniería (ICAI)
Página 5
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
denominadas “moders” que consisten en extensiones para el juego original que
proporciona nuevas aventuras, ambientaciones, personajes, objetos, etc.
Comodidad: Algunos juegos resultan incómodos jugarlos utilizando un joystick
o mando de consola como los juegos de estrategia en tiempo real.
Flexibilidad del hardware: Al poder incluir en el PC tarjetas de video de distinta
potencia en función a la capacidad económica del usuario o al rendimiento que
se desea se obtienen mayores resultados en calidad gráfica y de procesamiento
que las limitadas a consolas.
1.2.4
Videojuegos e Internet
Las grandes oportunidades de crecimiento de la industria del videojuego vienen
de Internet, tanto para las computadoras personales como para las consolas. Grandes
empresas como ElectronicArts o Nintendo han firmado convenios con America Online
(AOL) para proveer juegos en línea y entretenimiento interactivo para los suscriptores
de AOL.
En la actualidad, World of Warcraft desarrollado por BlizzardEntertainment es
el juego multijugador en línea con más suscriptores, 12 millones mensuales1. En 2010
se estimó que este juego mantenía el 67% del mercado multijugador masivo en línea
(MMOG).
1
http://www.vadejuegos.com/noticias/2010/10/07/mas-de-12-millones-de-suscriptores-para-world-ofwarcraft-153446.html
Escuela Técnica Superior de Ingeniería (ICAI)
Página 6
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
1.2.5
Motores de videojuego
Un motor de videojuego son una serie de rutinas de programación que permiten
el diseño, la creación y presentación de un videojuego. La funcionalidad básica de un
motor es de proveer al juego de un motor de renderizado para gráficos 2D y 3D, un
motor físico para la detección de colisiones, sonidos, una inteligencia artificial para el
control del entorno, una administración de memoria y la gestión de partidas online ya
sean LAN o a través de Internet.
1.2.5.1
UnrealEngine
El UnrealEngine es un motor de videojuego de PC y consolas desarrollado por la
compañía EpicGames. Fue uno de los motores más conocidos para shooters en primera
persona como el UnrealTournament, Gears of Wars o Batman: ArkhamAsylum.
Figura 3 – UnrealEngine
También ha sido utilizado en otros géneros como el rol y de perspectiva en
tercera persona. Está implementado en C++ y es compatible con varias plataformas
como PC (Windows y GNU/Linux), Apple Macintosh y la mayoría de las consolas.
Su última versión apareció en 2006 y fue diseñado para PC, Xbox 360 y
PlayStation 3. El motor soporta técnicas avanzadas como HDRR, normal mapping y
sombras dinámicas. Permite la renderización de un número elevado de objetos
simultáneos, físicas más realistas para efectos del agua, IA mejorada y efectos de luces
y sombras con rutinas más avanzadas.
Escuela Técnica Superior de Ingeniería (ICAI)
Página 7
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
Debido a su política de licencias, consiguió numerosos contratos con Atari,
Activision, Ubisoft, Sega, ElectronicArts, entre otras.
Según la popular revista IGN el motor Unreal fue considerado uno de los
mejores motores para videojuegos en 2009. Sus principales ventajas son su gran
eficiencia pudiendo funcionar en ordenadores tanto de gama alta como del gama bajamedia sin reducir considerablemente sus prestaciones ysu estandarización y aceptación
dentro de la industria de los videojuegos. Por desgracia, para poder utilizar este motor
es necesario tener unos conocimientos de programación altos para poder desarrollar
videojuegos aceptables. Otro de sus puntos débiles que comparte con la gran mayoría de
motores existentes es que una vez generado el videojuego es imposible por parte del
usuario modificarlo.
1.2.5.2
UnityEngine
Unity es una herramienta para la creación de videojuegos en 3D y otros tipos de
contenidos interactivos tales como visualizaciones arquitectónicas o animaciones en
tiempo real en 3D. elUnityEngien es compatible con diferentes plataformas tales como
Windows, Mac, Xbox 360, Play Station 3, Wii, iPhone y Android. También permite el
desarrollo de videojuegos de navegador web utilizando el plugin para navegadores de
Unity. Permite la exportación de videojuegos a formato Flash pero ciertas
funcionalidades soportadas por el pluginUnity no pueden ser utilizadas en Flash debido
a sus limitaciones. El motor de videojuegos Unity es utilizado por más de 500,000
desarrolladores.
Figura 4 – UnityEngine
Unity consiste tanto en un editor para el desarrollo y diseño de contenidos como
en un motor de videojuegos para el producto final. Una de sus principales ventajas su
portabilidad a plataformas como videoconsojas o móviles iPhone y Android aunque esta
Escuela Técnica Superior de Ingeniería (ICAI)
Página 8
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
posibilidad requiere de una licencia adicional. Otra de sus ventajas es que para su
desarrollo se permite el uso del lenguaje script UnityScript, C# o Boo (insipirado en la
sintaxis de Python), lenguajes de alto nivel sencillos de utilizar. Pese a esto, el usuario
final no podrá modificar los videojuegos que haya adquirido para este motor siendo ésta
una de sus mayores desventajas.
Escuela Técnica Superior de Ingeniería (ICAI)
Página 9
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
1.2.6
TheMetaGameProject
Pensado por BarneyPell, la idea que sugería era crear un programa que sirviese
para poder jugar diferentes juegos. A partir de unas reglas de juego, el programa las
interpretaba y aprendía a jugar dicho juego.
Propuso una clase que llamó “symmetricchess-likegames” (simetría de juegos
parecidos al ajedrez) y desarrolló el programa MetagameWorkbench para poder trabajar
sobre ellos. Este programa podía interpretar reglas de este tipo de juegos y generar
juegos aleatorios nuevos.
La idea de este programa era crear juegos de este tipo que pudiesen ser
comprensibles y jugables. Para ello, al generar las reglas el programa, las traducía a un
lenguaje más simple “GameDescriptionLanguage in theMetagameWorkbench”.
El programa está escrito en Prolog. Este lenguaje lo hace útil para metajuegos
sencillos pero no de alto nivel.
Figura5 – Diagrama de flujo “theMetagame Project”
Escuela Técnica Superior de Ingeniería (ICAI)
Página 10
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
1.2.7
Lenguajes Script
Un lenguaje interpretado es un lenguaje de programación diseñado para ser
ejecutado mediante un intérprete, a diferencia de los lenguajes compilados. Muchos
lenguajes han sido implementados usando tanto compiladores como intérpretes, como
por ejemplo Lisp, Pascal o Python.
Inicialmente, los lenguajes interpretados eran compilados línea a línea, es decir,
cada línea era compilada a medida q iba a ser ejecutada. El problema de esta técnica era
que si se iba a ejecutar un loop, las líneas dentro de éste tenían que ser recompiladas
repetidamente.
Actualmente, la mayoría de los lenguajes interpretados utilizan una
representación intermedia que combina tanto la compilación como la interpretación. El
compilador puede producir una interpretación intermedia como el bytecode que será
ejecutado por un intérprete de bytecode.
Las ventajas de un lenguaje script o interpretado es que ofrecen una flexibilidad
adicional frente a los lenguajes compilados. Algunas características más sencillas de
implementar sobre intérpretes son:
Independencia de la plataforma.
Tipos de datos dinámicos.
Mayor facilidad en la depuración.
Gestión de la memoria automática.
Por el contrario, la mayor desventaja de los lenguajes script radica en que es
menos eficiente su ejecución. El motivo es que cada instrucción debe de pasar por una
interpretación en tiempo de ejecución por lo que es menos eficiente en tiempo. La
máquina virtual es una solución parcial a este problema ya que realiza una definición a
un lenguaje intermedio que es más cercano al lenguaje de máquina y su traducción es
más sencilla en tiempo de ejecución.
Otra desventaja remarcable es la necesidad de tener un intérprete en la máquina
donde se vaya a ejecutar la aplicación.
Escuela Técnica Superior de Ingeniería (ICAI)
Página 11
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
1.2.7.1
Basic4GL
Es un lenguaje de programación interpretado gratuito para Microsoft Windows
con soporte para la librería gráfica OpenGL. Fue diseñado para que fuese sencillo su
aprendizaje y sencillo de utilizar para el desarrollo de aplicaciones en 3D como juegos,
demos y otro tipo de utilidades sin todos los problemas de configuración asociados con
la mayoría de lenguajes compilados. Sus principales ventajas son:
Herramienta gratuita y de fácil aprendizaje.
Entorno para el aprendizaje de OpenGL y los conceptos básicos de
gráficos en 3D.
Útil para el desarrollo de juegos sencillos o pequeñas demostraciones
gráficas.
Su principal desventaja es que, al ser tan sencillo no ofrece todo el potencial de
OpenGL limitando demasiado su uso.
1.2.7.2
Perl
Es un lenguaje de programación diseñado por Larry Wall en 1987. Toma
características del lenguaje C, Shell y Lisp. Fue originalmente desarrollado para la
manipulación de texto pero ahora se utiliza para la administración de sistemas,
desarrollo web, desarrollo GUI y otras utilidades. Es sencillo de utilizar y tiene soporte
para programación estructurada y orientada a objetos.
Figura 6 – Logo Perl
En un estudio realizado por “ComputerLanguageShootoutBenchmarks” se
comparó su funcionamiento con otros lenguajes interpretados y compilados. La
conclusión fue que utiliza más memoria que las implementaciones de otros lenguajes
afectando a la velocidad de ejecución.
Escuela Técnica Superior de Ingeniería (ICAI)
Página 12
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
1.2.7.3
Python
Es un lenguaje de programación muy expresivo, es decir, los programas Python
son muy compactos: suele ser bastante corto en comparación con otros lenguajes de
programación de alto nivel. Su sintaxis es muy legible, mucho más sencilla que la de
otros lenguajes. A parte, posee un rico juego de estructuras de datos que pueden
manipularse de una forma sencilla e intuitiva para el desarrollador.
1.2.7.4
Ruby
Es un lenguaje de programación interpretado, reflexivo y orientado a objetos
creado por el programador japonés YukihiroMatsumoto que lo presentó públicamente
en 1995. Su sintaxis está inspirada en Python y Perl. Según su propio creador “Ruby es
simple en apariencia, pero complejo por dentro, como el cuerpo humano”. Su principal
objetivo es desarrollar un lenguaje natural, no simple.
Figura 7 – Logo Ruby
Se trata de un lenguaje flexible ya que permite al desarrollador alterarlo
libremente. Las partes esenciales de Ruby pueden ser eliminadas o redefinidas. Se
puede agregar funcionalidad a partes ya existentes permitiendo no restringir al
desarrollador.
1.2.7.5
VBScript
Visual Basic Script Edition es un lenguaje interpretado por el Windows
Scripting Host de Microsoft. Su sintaxis es una variación de lenguaje de programación
Visual Basic. Es parte fundamental de la ejecución de aplicaciones de servidor
programadas en ASP (Active Server Pages). Solo puede ser utilizado en la plataforma
Microsoft Windows.
Escuela Técnica Superior de Ingeniería (ICAI)
Página 13
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
1.2.7.6
NWNScript
Es un lenguaje interpretado utilizado en el videojuego NeverwinterNights y
NeverwinterNights 2. Su principal función es la de permitir a un desarrollador crear
nuevos mods para estos juegos aumentando su historia, criaturas, objetos, etc.
Escuela Técnica Superior de Ingeniería (ICAI)
Página 14
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
2. Alcance del Proyecto
Escuela Técnica Superior de Ingeniería (ICAI)
Página 15
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
2.1 Motivación
El desarrollo de juegos para ordenador ha planteado desde siempre pero ahora
más que nunca debido a las nuevas tecnologías una dificultad muy elevada para los
desarrolladores noveles y con poca o ninguna experiencia en este campo. Cada vez más,
los desarrollos de juegos no realizan una diferenciación entre la lógica o
comportamiento de un juego de su visualización final debido a la complejidad que esto
conlleva y a que no suele reutilizarse el código para nuevos desarrollos.
Este proyecto busca desarrollar una aplicación que facilite el desarrollo de
juegos para usuarios con ciertos conocimientos de programación. Para ello será
necesario separar y definir bien la lógica del juego de la interfaz de éste abstrayendo al
desarrollador del funcionamiento interno de la aplicación y dándole libertad total a la
hora de definir las reglas del juego y los elementos que forman parte de él sin estar
condicionado por la herramienta.
Gracias a este aspecto se permitirá la reutilización de código ya que al haber
realizado una separación bien definida de la lógica del juego, un desarrollador podrá
modificar las reglas de un juego desarrollado anteriormente por él mismo o por un
tercero y los elementos que participan en éste creando una nueva versión y, por lo tanto,
ofreciendo al usuario final una nueva experiencia.
Se ha conseguido desarrollar un motor de videojuego totalmente interpretado
abriendo la posibilidad de alterar el juego por parte del usuario final. Debido a las
limitaciones de tiempo propias de un Proyecto Fin de Carrera se ha desarrollado solo
para juegos de estrategia por turnos.
A diferencia de los motores de videojuegos nombrados en el apartado 1.2.5, este
motor sólo se ha enfocado a la parte lógica de un videojuego dejando para un posible
futuro su versión gráfica.
Escuela Técnica Superior de Ingeniería (ICAI)
Página 16
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
2.2 Objetivos
El objetivo es desarrollar un marco de programación en el que, mediante un
lenguaje de script y XML, se pueda expresar la lógica de un juego de mesa por turnos
para su interpretación en tiempo de ejecución. Se deberá desarrollar tanto la interfaz con
el lenguaje de script como el propio intérprete.
Para alcanzar este objetivo es necesario marcar una serie de objetivos más
específicos:
Desarrollo y diseño de un modelo general de la lógica de los juegos de
mesa por turnos para su interpretación.
Desarrollo conceptual de la interfaz entre el intérprete y el código script.
Elección de un lenguaje script a utilizar.
Diseño y desarrollo del intérprete.
Ejecución por parte del intérprete del desarrollo script.
Implementación de un juego real: Para la realización de las pruebas de
la aplicación se han desarrollado las reglas del Risk y se han definido los
elementos que participan en dicho juego.
Se deberán tener en cuenta las siguientes características:
Juegos multijugador: La aplicación (kernel) tiene que ser capaz de de
permitir partidas de uno o más jugadores dependiendo de las
propiedades del juego.
Sencillo de utilizar: La aplicación (kernel) tiene que ser sencilla e
intuitiva separando bien los diferentes elementos del juego y las reglas
de éste.
Escuela Técnica Superior de Ingeniería (ICAI)
Página 17
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
Escuela Técnica Superior de Ingeniería (ICAI)
Página 18
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
3. Tecnologías
Escuela Técnica Superior de Ingeniería (ICAI)
Página 19
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
3.1 C++
C++ es un lenguaje de programación diseñado a mediados de los años ochenta
por BjarneStroustrup. Su intención era la de extender el exitoso lenguaje de
programación C con mecanismo que permitiesen el manejo de objetos. Posteriormente
se añadieron otros dos paradigmas que ya estaban admitidos: programación estructurada
y programación orientada a objetos. Por este motivo, C++ es considerado un lenguaje de
programación multiparadigma. 2
Actualmente existe un estándar para este lenguaje, denominado ISO C++, al que
se adhirieron la mayoría de los desarrolladores de compiladores de este lenguaje.
Otra particularidad de este lenguaje es la posibilidad de redefinir los operadores,
o comúnmente denominado “sobrecarga de operadores” que nos permite utilizar los
operadores básicos con las clases desarrolladas.
2
http://es.wikipedia.org, http://www.cplusplus.com
Escuela Técnica Superior de Ingeniería (ICAI)
Página 20
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
3.2 XML
Extensible MarkupLanguage (XML) es un metalenguaje extensible de
etiquetado desarrollado por el World Wide Web Consortium (W3C). Consiste en una
simplificación y adaptación del lenguaje GML (GeneralizedMarkupLanguage)
desarrollado por IBM en los años setenta que surgió por la necesidad de dicha empresa
para almacenar grandes volúmenes de información.
XML permite definir la gramática de lenguajes específicos. XML no es
considerado un lenguaje de programación sino que es una herramienta para definir
lenguajes específicos para diferentes necesidades. Este lenguaje no nació únicamente
para su aplicación en Internet sino que se propuso como un estándar para el intercambio
de información de una manera estructurada entre diferentes plataformas.
Una de las ventajas más remarcable de este metalenguaje es su extensibilidad.
Después del desarrollo y puesto en producción, es posible extender XML con la adición
de nuevas etiquetas sin verse afectado el código anterior. Por lo tanto, si un tercero
decide utilizar el documento XML, podrá comprenderlo gracias a su desarrollo
estructurado.
Como se ha comentado anteriormente, XML es un metalenguaje basado en el
etiquetado. Dichas etiquetas consisten en marcas en el documento que señalan una
porción de éste como un elemento. Las etiquetas son definidas como “<nombre>”
donde “nombre” es el identificador del elemento marcado.
A continuación se muestra un pequeño ejemplo para comprender la estructura de
un documento XML:
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE Edit_Mensaje SYSTEM "Edit_Mensaje.dtd">
<Ficha>
</Ficha>
<Nombre>Antonio</Nombre>
<Apellido>Rodríguez</Apellido>
<Estudios>Ingeniería</Estudios>
Escuela Técnica Superior de Ingeniería (ICAI)
Página 21
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
Los documentos XML bien formados (“wellformed”) son aquellos que cumplen
las definiciones básicas de formato. Esto es útil ya que si un documento está bien
formado podrá ser interpretado por cualquier analizador sintáctico que cumpla con la
norma.
Estructura jerárquica: El modelo de etiquetado del documento tiene que
seguir una estructura estrictamente jerárquica, es decir, las etiquetas tiene
que estar correctamente anidadas y cualquier elemento con contenido
tiene que estar cerrado.
Solo puede existir un elemento raíz en todo el documento.
Es necesario asignar nombres a todos los elementos presentes en el
documento XML.
Uno de los principales motivos por el que se ha elegido este lenguaje para el
almacenamiento de la información del juego ha sido su estructura jerárquica que
permite la creación de elementos con diferentes atributos y propiedades. A parte, puesto
que todos los elementos tienen que tener asignado un nombre se evita la inclusión de
información incompleta por parte del usuario.
3.2.1
TinyXML
TinyXML es una librería para analizar código XML para el lenguaje C++. Es un
producto de código abierto y gratuito distribuido bajo la licencia zlib/libpng. Analiza y
procesa el código XML en un árbol DOM (Documento ObjectModel) y es capaz tanto
de leer código XML como de generarlo. Cada una de las etiquetas del documento XML
son consideradas por la librería TinyXML como nodos (TiXmlNode) dentro de un árbol
en el que cada etiqueta incluida dentro de otra forma parte de un nodo hijo y nodo padre
respectivamente.
Se ha decidido utilizar esta librería ya que es un producto gratuito bajo licencia
zlib/libpng y es una librería sencilla de utilizar.
Escuela Técnica Superior de Ingeniería (ICAI)
Página 22
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
3.3 PYTHON
Python es un lenguaje de programación de alto nivel interpretado creado a
finales
de
los
ochenta
por
Guido
van
Rossum
en
el
NationalResearchInstituteforMathematics and ComputerScience (CWI), en los Países
Bajos. Su idea original era ser el sucesor del lenguaje de programación ABC, capaz de
manejar excepciones e interactuar con el sistema operativo Amoeba.
Figura 1 – Logotipo de Python
La filosofía de este lenguaje es la de hacer hincapié en una sintaxis muy limpia
favoreciendo un
código
legible. Python
es
un lenguaje
de
programación
multiparadigma, es decir, en vez de adoptar un estilo particular de programación
permite utilizar una filosofía orientada a objetos, imperativa o funcional.
Otra característica importante es la resolución dinámica de nombres. Lo que
enlaza a un método o un nombre de variable durante la ejecución de un programa se
resuelve de forma dinámica.
En Python todo es un objeto, incluidas las clases. Las clases, puesto que son
consideradas objetos, son instancias de una metaclase. Además puede soportar herencia
múltiple, es decir, una clase puede heredar comportamientos y características de más de
una superclase. Aparte, soporta polimorfismo que consiste en que varias clases
derivadas de una antecesora puedan utilizar un mismo método de forma diferente.
3.3.1
Boost.Python
Boost es un conjunto de librerías de software libre creadas originalmente por
BemanDawes y David Abrahams utilizadas para extender las capacidades del lenguaje
de programación C++. Boost está formado por más de ochenta librerías individuales
incluidas las librerías de procesamiento de cadenas, contenedores, procesamiento de
Escuela Técnica Superior de Ingeniería (ICAI)
Página 23
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
imágenes y diferentes algoritmos. La mayoría de librerías no necesitan ser construidas
para su uso. Pueden ser utilizadas en cualquier tipo de proyectos, ya sean comerciales o
no. Varios de los fundadores de Boost forman parte del Comité ISO de Estándares C++
mencionado en el apartado 1. La próxima versión estándar de C++ incorporará varias de
estas librerías. Actualmente cuenta con más de 3.000 personas suscritas a la lista de
correo.
Boost.Python es una librería del conjunto de librerías Boost. Permite exportar las
clases y tipos de datos definidos en C++ a Python. Fue diseñada pensando en que no
fuese necesario modificar las clases desarrolladas en C++ para que el intérprete de
Python pudiese utilizarlas. Todas las funcionalidades de esta librería han sido
desarrolladas en C++ por lo que no es necesaria una herramienta externa para
utilizarlas.
Actualmente, Python cuenta con una API para C++ que permite la interacción
entre estos dos lenguajes. La librería Boost.Python añade cuatro características
importantes a dicha API:
Intercambio de objetos: Como se ha comentado anteriormente,
Boost.Python permite que el intérprete de Python conozca la estructura y
las funcionalidades de las clases desarrolladas en C++. Gracias a un
diccionario de datos es posible intercambiar objetos creados en C++ con
Python y viceversa.
Sobrecarga
de
clases:Boost.Python
permite
añadir
nuevas
funcionalidades a las clases desarrolladas en C++ manteniendo el
paradigma de la Programación Orientada a Objetos para que únicamente
sean utilizables por el intérprete de Python.
Control de errores: Incluyendo el fichero “module_tail.cpp” al final del
fichero fuente C++ donde se invoca a Python, es posible controlar el
lugar donde el código Python falla traduciéndolo a una excepción de
C++.
Tratamiento de tipos básicos de C++: Boost.Python también permite
utilizar las operaciones de objetos básicos de C++ en Python siguiendo el
Escuela Técnica Superior de Ingeniería (ICAI)
Página 24
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
estilo de la Programación Orientada a Objetos. Por ejemplo, para escribir
en Python la siguiente línea de código en C++
x = vector[i];
Utilizando la API básica de Python sería:
x = PySequence_GetItem(vector, i);
En cambio, si se utiliza la librería Boost.Python:
x = vector[i];
Tanto la API básica de Python para C++ como la librería Boost.Python pueden
convivir juntas en la misma aplicación. Si es necesario incluir alguna funcionalidad de
la API básica no es necesario incluir la cabecera Python.h ya que viene incluida en la
librería Boost.Python.
3.3.2
Boost.Python: Ejemplo
A continuación se va a explicar cómo conseguir que el intérprete de Python
pueda comprender y utilizar las clases desarrolladas en C++. Para este ejemplo se
utilizará una clase sencilla en C++:
class HolaMundo
{
private:
string nombre;
public:
HolaMundo(string nombre);
~HolaMundo();
void set_nombre(string nombre);
string get_nombre();
void saludo();
};
El primer paso consistiría en crear el módulo Boost.Python al que accedería
Python para interpretar la clase HolaMundo.
Escuela Técnica Superior de Ingeniería (ICAI)
Página 25
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
#include <boost/python.hpp>
namespace python = boost::python;
using namespace boost::python;
BOOST_PYTHON_MODULE(HolaMundo)
{
python::class_<HolaMundo>("HolaMundo")
.def("setnombre", &HolaMundo::set_nombre)
.def("getnombre", &HolaMundo::get_nombre)
.def("saludoPython", &HolaMundo::saludo);
}
A continuación, es necesario añadir el módulo Python generado anteriormente al
intérprete de Python. En caso de que no se pudiese se lanzaría un error informando de
esto. Siempre que se vaya a utilizar cualquier código de la librería Boost.Python o de la
API original de Python para C++ éste debe de comenzar con “Py_Initialize();”.
Py_Initialize();
if (PyImport_AppendInittab("HolaMundo ", initHolaMundo) == -1)
throw std::runtime_error("Failed to add HolaMundo to the interpreter's "
"builtin modules");
Por último obtenemos el espacio de nombres o diccionario de datos que
comparten Python y nuestro programa realizado en C++.
python::object main = python::import("__main__");
// Retrieve the main module's namespace
python::object global(main.attr("__dict__"));
python::object PythonDerived = global["PythonDerived"];
A partir de este momento se podrá utilizar el objeto “global” para importar
objetos entre los diferentes lenguajes sin compartición de memoria por lo que un objeto
importado desde C++ a Python no podrá ser actualizado desde éste pero sí podrá ser
modificado para poder recogerlo nuevamente desde C++.
HolaMundo variable(“C++”);
Escuela Técnica Superior de Ingeniería (ICAI)
Página 26
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
Global[“variable”] = variable;
El último paso consistiría en invocar al fichero Python que recibirá la variable
global y que hará uso de la clase desarrollada en C++.
python::object result = python::exec_file(“ejemplo.py”, global, global);
Para recuperar desde C++ una variable utilizada en Python habría que utilizar el
objeto “global”.
HolaMundoaux = python::extract<HolaMundo>(global["auxiliar"]);
A continuación se muestra el fichero Python que se ha utilizado para desarrollar
el ejemplo.
# Fichero ejemplo.py
importHolaMundo
print '¡Hola Mundo!'
variable.saludoPython();
auxiliar = HolaMundo("Python");
auxiliar.saludoPython();
Salida del programa:
¡Hola Mundo!
Hola desde la variable de C++
Hola desde la variable de Python
Para más información sobre el uso de la librería Boost.Python es recomendable
leer el manual desarrollado por Boost:
http://www.boost.org/doc/libs/1_46_1/more/getting_started/index.html
Escuela Técnica Superior de Ingeniería (ICAI)
Página 27
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
4. Arquitectura
Escuela Técnica Superior de Ingeniería (ICAI)
Página 28
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
4.1 Arquitectura del Sistema
En este apartado se describirá la arquitectura interna del sistema desarrollado y
se describirá el alcance del proyecto dentro del ámbito de los módulos funcionales
desarrollados para su ejecución.
Como se puede observar en la siguiente figura, en un primer estudio se decidió
definir el sistema con dos grandes módulos:
Figura 1 – Arquitectura del Sistema inicial
El grado de alcance de cada módulo es el siguiente:
Información y reglas del juego: Engloba toda la información relativa al
juego y necesaria para poder jugar.
Kernel: Es el módulo encargado de procesar la información del juego,
interpretar las reglas y gestionar el flujo de la partida.
En un primer momento se decidió definir las reglas del juego utilizando el
lenguaje XML. Para ello se estudió la posibilidad de utilizar una pila para almacenar las
distintas variables que se utilizasen y, mediante las funciones definidas en el módulo
Kernel y las operaciones de push y poppropias de una pila, ejecutar las reglas del juego
según el estado del juego en el que se encontrase el jugador.
Escuela Técnica Superior de Ingeniería (ICAI)
Página 29
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
La principal ventaja que aportaba este modelo era poder definir tanto las reglas
como la información del juego con un lenguaje sencillo y sin necesidad de compilación
en caso de modificación del algún parámetro del juego.
Se desarrolló una primera versión conceptual del Risk utilizando este esquema
pero, pese a ser factible y tratarse de un lenguaje muy sencillo de utilizar, se llegó a la
conclusión de que no cumplía los objetivos marcados. Con juegos sencillos o de poca
complejidad, este mecanismo era sencillo de utilizar pero con juegos con unas reglas de
mayor complejidad se hacía bastante difícil desarrollarlas utilizando XML. Ante esta
situación se decidió utilizar otra técnica para la definición de las reglas del juego. Como
se puede observar en la siguiente figura, se llegó a la conclusión de que era necesario
separar las reglas del juego de la información de éste creando un nuevo módulo:
Figura 2 – Arquitectura del Sistema
El grado de alcance de cada módulo es el siguiente:
Reglas del juego: Engloba todas las acciones que pueden realizarse en el
juego.
Información del juego: Engloba toda la información del juego así como
los diferentes estados por los que puede transcurrir una partida.
Kernel: Es el módulo encargado de leer la información del juego y las
reglas de éste y controlar el flujo de una partida.
Escuela Técnica Superior de Ingeniería (ICAI)
Página 30
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
Utilizando este nuevo diseño las reglas del juego ya no tendrán que desarrollarse
el lenguaje XML sino que se utilizará el lenguaje Python, mucho más potente aunque de
más complejidad, para desarrollarlas.
Las principales ventajas que aporta este nuevo modelo son las siguientes:
Separación entre reglas del juego e información:Las reglas del juego
estarían desarrolladas con el lenguaje Python y la información del juego
se plasmaría mediante el lenguaje XML estando los dos grandes bloques
totalmente separados.
Modificación de las reglas del juego: Debido a que las reglas del juego serán
desarrolladas mediante el lenguaje interpretado Python, no es necesario
recompilar su código para el correcto funcionamiento de la aplicación
permitiendo su modificación por terceros y creando nuevas versiones del
juego.
Diseño de Scripts: En un futuro sería posible desarrollar un IDE que permita la
generación de los scripts en Python de una forma sencilla e intuitiva sin
necesidad de programarlos.
Una desventaja de tener que utilizar este lenguaje para el desarrollo de las reglas
del juego es la necesidad de tener instalado en el equipo que vaya a ejecutar el juego un
intérprete de Python. Sin dicho intérprete no se podrían procesar las reglas del juego y,
por consiguiente, no se podría utilizar la aplicación.
Escuela Técnica Superior de Ingeniería (ICAI)
Página 31
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
4.2 Módulo: Información del juego
A continuación se describirá la arquitectura interna del módulo Información del
Juego.
Puesto que cada juego de mesa consta de diferentes elementos que le diferencian
del resto de juegos, se estudiaron los elementos comunes en diferentes juegos de mesa
por turnos que pueden observarse en la siguiente figura:
Figura 3 – Arquitectura del módulo “Información del juego”
Como se puede observar, este módulo consta de seis unidades funcionales cuyo
grado de alcance es el siguiente:
Estados: Engloba los diferentes estados por los que puede transcurrir una
partida del juego. Constará de un estado inicial y un estado final que
definan el principio y fin del turno del jugador. Los estados funcionan
como una máquina de estados existiendo eventos de salida y entrada.
Propiedades del juego: Define las variables generales del juego como
pueden ser el número de jugadores, nombre del juego, etc.
Propiedades del jugador: Define las variables comunes de los
jugadores de una partida como nombre del jugador, elementos del juego
de los que dispone, etc.
Escuela Técnica Superior de Ingeniería (ICAI)
Página 32
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
Unidades: Son los diferentes elementos del juego que pueden pertenecer
o no a un jugador y que participan en la partida.
Recursos: Son los diferentes elementos del juego que pertenecen a un
jugador pero que no participan activamente en el juego.
Estructuras: Son los diferentes elementos del juego que pueden
pertenecer o no a un jugador y que participan en la partida pero que se
mantienen en una posición fija durante toda la partida.
Todas estas unidades funcionales se desarrollarán en XML ya que se trata de un
lenguaje sencillo de utilizar y que no requiere recompilar el código si alguna de estas
unidades funcionales necesita modificarse.
Escuela Técnica Superior de Ingeniería (ICAI)
Página 33
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
4.3 Módulo: Reglas del juego
Este módulo será el encargado de definir las reglas o acciones que podrán
realizarse a lo largo de la partida. La arquitectura interna se define en la siguiente figura:
Figura 4 – Arquitectura del módulo “Reglas del juego”
Las reglas del juego consisten esencialmente en funciones desarrolladas en
Python que realizan los siguientes cometidos:
Operaciones: En función a los datos que reciban tendrán que obtener
uno o varios datos de salida mediante operaciones tanto lógicas como
matemáticas.
Modificación de la Información del juego: En base a las acciones
realizadas por el jugador, las reglas del juego podrán alterar la
información del juego.
Modificación de los estados de la máquina de estados: En función a
una serie de eventos señalados en las reglas del juego podrán afectar a los
estados de la máquina de estados del juego.
Como puede observarse, este módulo consta de tres unidades funcionales fundamentales
cuyo grado de alcance es el siguiente:
Escuela Técnica Superior de Ingeniería (ICAI)
Página 34
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
Inicio del juego: Define la primera regla o acción a realizar nada más
comenzar el juego. Esta consistirá en el reparto de recursos, unidades y
estructuras iniciales a cada jugador, posicionamiento de éstos, etc.
Fin del juego: Define la última regla o acción que se realizará al
finalizar el juego.
Reglas del juego: Engloba el resto de reglas que se irán ejecutando
conforme el juego avance según el estado en el que se encuentre cada
jugador. Al contrario que las dos unidades funcionales anteriores, estas
reglas no tendrán que ejecutarse obligatoriamente en todas las partidas.
Estas unidades funcionales se desarrollarán utilizando el lenguaje Python por los
motivos explicados en el apartado 3.3.
Escuela Técnica Superior de Ingeniería (ICAI)
Página 35
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
4.4 Módulo: Kernel
Este módulo será el encargado de leer la información proporcionado por los
otros dos módulos principales y controlar el flujo de la partida. En la siguiente figura se
pueden ver las principales unidades funcionales que forman parte de él:
Figura 5 – Arquitectura del módulo “Kernel”
Es considerado el módulo principal invariable para los juegos que se desarrollen
en un futuro ya que estará implementado en C++ y debe de ser común para todos los
juegos. Como puede observarse, el módulo principal consta de cuatro unidades
funcionales principales que se definen de la siguiente manera:
Lector de Información del Juego
Se encarga de procesar todos los ficheros XML con la información relativa al
juego y almacenarla en variables declaradas en el Kernel en C++. Su invocación se
realiza desde el Kernel nada más arrancar la aplicación y leerá los 6 ficheros XML
definidos: recursos.xml, juego.xml, unidades.xml, estructuras.xml, estados.xml y
jugador.xml.
Interactúa estrechamente con el resto de unidades funcionales ya que
proporciona información importante para todos ellos. La unidad funcional Jugadores
necesita la información que se refiere tanto al jugador en sí como los elementos que
forman parte del juego.Gestor de Estados necesita toda la información referente a los
estados por los que pasa el juego y los saltos que pueden producirse de uno a otro. Por
Escuela Técnica Superior de Ingeniería (ICAI)
Página 36
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
último, la unidad funcional Gestor de Acciones necesita conocer qué acción o función
debe de lanzar en cada momento.
Jugadores
Guarda toda la información de los jugadores que participan en una partida. Es
una unidad funcional que se actualiza continuamente ya que, con cada acción que se
realiza durante el juego y que se vean afectados los jugadores, se verá afectada la
información que almacena.
La información la obtiene en primer lugar gracias al Lector de Información del
Juego que le proporciona los elementos iniciales con los que comienza cada jugador.
Durante el resto de la partida su contenido se verá alterado por las acciones que
son disparadas a través del Gestor de Acciones.
Gestor de Estados
El Gestor de Estados es el encargado de guardar toda la información de los
diferentes estados por los que puede discurrir una partida y gestionar los saltos entre
ellos. Obtiene dicha información a partir del fichero “estados.xml” que es leído por la
unidad funcional Lector de Información del Juego. Durante la partida es posible que
alguna acción modifique uno de dichos estados alterando el curso de acción de un turno
de un jugador.
Gestor de Acciones
El Gestor de Acciones es el encargado de gestionar las acciones que se producen
durante el turno de un jugador. Cada estado tendrá asociadas una o varias acciones que
deben de ejecutarse mientras el jugador permanezca en ese estado. Dichas acciones
pueden ser de dos tipos:
Internas: Son aquellas acciones incluidas en el módulo Kernel comunes
a cualquier juego de mesa por turnos desarrolladas en C++. Estas
Escuela Técnica Superior de Ingeniería (ICAI)
Página 37
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
funciones se han desarrollado previamente y el usuario podrá acceder a
ellas sin necesidad de reprogramarlas para cada nuevo juego.
Externas: son aquellas acciones implementadas en el módulo “Reglas
del Juego”. Para poder ejecutarlas tendrá que invocar al fichero Python
donde
está
definida
dicha
regla.
Esta
llamada
se
realizará
automáticamente cuando el jugador acceda al estado que la activa. Estas
funciones serán desarrolladas por el usuario de la aplicación.
Escuela Técnica Superior de Ingeniería (ICAI)
Página 38
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
Escuela Técnica Superior de Ingeniería (ICAI)
Página 39
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
5. Diseño del Sistema
Escuela Técnica Superior de Ingeniería (ICAI)
Página 40
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
5.1 Introducción
El Diseño de Sistemas se considera el arte de definir la arquitectura de un
sistema, tanto hardware como software para poder satisfacer una serie de
requerimientos.
Esta etapa está considerada una de las más cruciales en el desarrollo de software
ya que en función de la calidad de este diseño el sistema tendrá un comportamiento
acorde con los requerimientos especificados o bien tendrá anomalías en su
funcionamiento teniendo que redefinir el diseño y, por lo tanto, incrementado los costes
del producto.
En el caso de este proyecto solo será necesario un diseño a nivel software ya que
será una aplicación capaz de funcionar en cualquier computadora que cumpla los
requisitos especificados y no será necesaria una máquina específica para el hardware.
Escuela Técnica Superior de Ingeniería (ICAI)
Página 41
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
5.2 Diagrama de Secuencia
A continuación se muestra un diagrama de secuencia de cómo se resolvería
dentro de la aplicación el turno de un jugador.
Figura 2 – Diagrama de Secuencia
Escuela Técnica Superior de Ingeniería (ICAI)
Página 42
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
En primer lugar la aplicación solicita a la clase Inf_Jugador el estado en que se
encuentra el jugador actual, es decir, el jugador que va a jugar en ese momento el turno
y evalúa el valor devuelto. En caso de que el estado del jugador sea -1 el jugador ha sido
eliminado en algún momento de la partida. La aplicación entonces cambiará el jugador
actual por el siguiente jugador disponible y finalizará el turno de ese jugador.
Si el estado del jugador es distinto de -1 la aplicación solicitará al
ManagerFunciones, que es el encargado de gestionar todas las funciones, la función
específica para mostrar la Información del Jugador y la ejecutará. Esta acción mostrará
por pantalla toda la información del jugador.
A continuación la aplicación solicitará a la clase FuncionPython que ejecute la
regla “finjuego.py”. Esta regla lo que hará será comprobar si el usuario ha llegado al
final del juego o no, es decir, si ha perdido o ganado la partida o si puede continuar
jugando.
La aplicación volverá a comprobar el estado del jugador y en el caso de que su
estado sea -1 finalizará su turno. Por el contrario, si su estado sigue siendo distinto de -1
la aplicación pedirá al ManagerEstados que seleccione el estado en el que está el
jugador. El ManagerEstados lo que hará será ejecutar la regla correspondiente a dicho
salto y devolverá el control a la aplicación. Esto se repetirá hasta que el jugador alcance
el salto final.
Escuela Técnica Superior de Ingeniería (ICAI)
Página 43
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
5.3 Diagrama de Flujo
A continuación se muestra un diagrama de flujo del turno de un jugador de un
juego de mesa por turnos genérico indicando los diferentes estados por los que podría
pasar durante una partida.
Figura 3 – Diagrama de Flujo
Durante el turno de un jugador existen dos estados obligatorios que aparecen en
todos los juegos de mesa por turnos.
Inicio turno:Este estado será el encargado de inicializar el turno del
jugador realizando las comprobaciones necesarias y desde él se
accederán a las primeras acciones del Juego que puede tomar un jugador
durante un turno.
Fin turno: Este estado será al que lleguen todos aquellos estados que
puedan ser de finalización del turno del jugador. En este turno se podrá
comprobar si el jugador cumple las condiciones necesarias para finalizar
la partida, comprobación de las unidades que se poseen al terminar el
turno, etc. Al terminar este estado se pasará el turno al siguiente jugador.
En el bloque que se representa en el diagrama de flujo como “Estados del Juego”
estarán todos aquellos estados que forman parte de la lógica de cada uno de los juegos
que se desarrollen. Podrán definirse todos los estados que se deseen teniendo especial
atención al identificador que se les asigne. Todos estos estados, incluidos los de Inicio
turno y Fin turno tendrán que estar definidos en el fichero XML estados.xml.
Escuela Técnica Superior de Ingeniería (ICAI)
Página 44
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
5.4 Diagrama de Clases
A continuación se muestra el diagrama de clases del módulo Kernel y la
descripción de cada una de las clases.
Figura 4 – Diagrama de Clases
Objeto
Contiene la información básica de cualquier clase que herede de Objeto. Estas
clases son las que se corresponden con cualquier elemento del juego.
Recurso
Contiene toda la información y funcionalidad relativa a los recursos del juego.
Cada uno de estos recursos podrá tener un conjunto de unidades y un conjunto de
atributos declarados por el usuario.
Escuela Técnica Superior de Ingeniería (ICAI)
Página 45
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
Elemento
Engloba a todas aquellas clases que puede asignársele un valor y una posición en
el tablero del juego.
Unidad
Almacena la información de una unidad del juego. Podrá tener una posición en
el tablero, un valor de movimiento, un atributo „tipo‟ que indica de qué tipo es la unidad
y un valor.
Estructura
Guarda la información de una estructura del juego. Dicha estructura podrá tener
una posición en el tablero y un atributo de tipo de estructura indicado por el
desarrollador del juego.
Evento
Almacena la información de un evento del juego. Tendrá una descripción y un
identificador del evento en cuestión.
Estado
Incluye la información de un estado del juego. Tendrá almacenada las
operaciones automáticas que se ejecutarán nada más alcanzar dicho estado y las
operaciones de salto.
OpSalto
Guarda la información de un salto entre estados. Tiene almacenado el
identificador del estado al que se va a saltar pudiendo ser modificable.
LectorXML
Es la clase encargada de procesar todos los archivos XML que guardan la
información del juego. Los archivos XML deben de estar implementados de forma
correcta tal y como se indica en el Anexo 2: Manual de Usuario.
Escuela Técnica Superior de Ingeniería (ICAI)
Página 46
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
ManagerFunciones
Es la clase encargada de almacenar todas las funciones o acciones que se
producirán en los diferentes estados del juego. A partir del identificador de la función
devolverá la función que tiene que ejecutar el Kernel.
ManagerEstados
Es la clase encargada de almacenar todos los estados por los que pasará un turno
de jugador. Será la encargada de seleccionar el salto de un estado a otro cuando el
jugador decida qué acción tomar.
CPosicion
Guarda toda la información necesaria para posicionar un elemento en el tablero
de juego. Podrá ser de n dimensiones en función del tipo de juego que se trate.
FCrearUnidades
Será la clase encargada de crear las unidades para un jugador. Se le podrán pasar
todos los parámetros que el jugador haya indicado para esa unidad.
Restricciones:
Primer parámetro: Número de unidades a crear.
Segundo parámetro: Jugador al que se le asignarán las unidades.
Tercer parámetro: Tipo de unidad.
FEliminarUnidades
Esta clase permitirá desde Python eliminar una serie de unidades de un jugador.
OpAutomatica
Clase encargada de gestionar las funciones automáticas de un estado.
Funcion
Esta clase almacenará la información necesaria de una acción de un estado.
También contiene el método ejecutar() que será el encargado de lanzar la acción.
Escuela Técnica Superior de Ingeniería (ICAI)
Página 47
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
FEliminarRecursos
Esta clase permitirá desde Python eliminar una serie de recursos de un jugador.
FCrearRecursos
Esta clase permitirá desde Python asignar una serie de recursos a un jugador de
la partida.
Restricciones:
Primer parámetro: Número de recursos a crear.
Segundo parámetro: Jugador al que se le asignarán los recursos.
Tercer parámetro: Tipo de recurso.
FTirarDados
Esta clase simulará la tirada de dados durante la partida indicándole el menor y
el mayor valor posibles. Esta clase podrá ser invocada desde Python.
FuncionPython
En esta clase se almacenará toda la información de una función Python y tendrá
el método que permitirá su ejecución.
FuncionKernel
En esta clase se almacenará toda la información de una función Kernel y tendrá
el método que permitirá su ejecución.
FInfoJugador
Esta clase podrá ser invocada desde Python para obtener toda la información de
un jugador, desde las unidades, recursos y estructuras que posee hasta el nombre del
jugador, su id, etc.
Escuela Técnica Superior de Ingeniería (ICAI)
Página 48
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
Escuela Técnica Superior de Ingeniería (ICAI)
Página 49
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
6. Risk
Escuela Técnica Superior de Ingeniería (ICAI)
Página 50
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
6.1 Introducción
El Risk es un juego de mesa de carácter estratégico creado por Albert Lamorisse
en 1950. Fue puesto a la venta por primera vez en Francia en el año 1957 bajo el
nombre de La Conquête Du Monde. Posteriormente, se comenzó a comercializar en
Estados Unidos bajo su actual nombre, Risk (en inglés Riesgo) en 1959. Las siguientes
modificaciones del juego se hicieron poniendo énfasis en la presentación y en nuevas
ediciones de éste.
El juego está basado en turnos y pertenece a la categoría de juegos de guerra
evocando las guerras Napoleónicas y su principal característica es su simplicidad y su
abstracción abarcando toda la geografía del mundo. Fue creado para un número de
jugadores de dos a seis de más de doce años y la duración de las partidas puede ser de
una a ocho horas en función del número de jugadores.
Figura 1 – Portada del juego Risk
Escuela Técnica Superior de Ingeniería (ICAI)
Página 51
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
6.2 Elementos del juego
Tablero
El tablero está formado de cuarenta y dos territorios agrupados en seis
continentes. Cada uno de estos continentes es de un color distinto y contiene de cuatro a
doce territorios.
Figura 2 – Tablero del juego Risk
América del Norte
África
1. Alaska
1. Congo
2. Alberta
2. África Oriental
3. América Central
3. Egipto
4. Estados Unidos del Este, compuesta
4. Madagascar
por el Noreste y el Sudeste de
5. África del Norte
Estados Unidos
6. Sudáfrica
5. Groenlandia
6. Territorios del Noroeste
7. Ontario
8. Quebec
9. Estados Unidos del Oeste
América del Sur
1. Argentina
Escuela Técnica Superior de Ingeniería (ICAI)
Asia
1. Afganistán
Página 52
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
2. Brasil
2. China
3. Perú
3. India
4. Venezuela
4. Irkutsk
5. Japón
6. Kamchatka
7. Oriente Medio
8. Mongolia
9. Siam
10. Siberia
11. Ural
12. Yakutsk
Europa
1. Gran Bretaña
Oceanía
1. Australia
Oriental,
compuesta
2. Islandia
por Queensland y por la Nueva Gales
3. Europa del Norte
del Sur
4. Escandinavia
2. Indonesia
5. Europa del Sur
3. Nueva Guinea
6. Ucrania
4. Australia Occidental
7. Europa Occidental
En el juego desarrollado para la aplicación cada territorio consistirá en un tipo
de recurso asignable a un jugador. Todos los territorios tendrán que pertenecer a un
jugador sin que exista la posibilidad de que haya un territorio neutral o no jugable.
Cada continente, a su vez, será también un recurso. Cuando un jugador haya
conquistado todos los países que lo conforman pasará a pertenecer a dicho jugador
consiguiendo las ventajas que le correspondan
Ejército
Escuela Técnica Superior de Ingeniería (ICAI)
Página 53
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
En el juego de mesa físico existen 6 grupos de ejércitos completos
diferenciados por un color, cada uno con 3 tipos de unidades: Infantería (Valor de un
ejército), Caballería (valor de cinco ejércitos) y Artillería (valor de diez ejércitos. En
cualquier momento del juego, un jugador puede intercambiar cinco ejércitos de
Infantería por uno de Caballería; diez ejércitos de Infantería por dos de Caballería o
uno de Artillería; y cinco ejércitos de Infantería y uno de Caballería por uno de
Artillería, o viceversa.
En el juego desarrollado para la aplicación no se realizará ninguna distinción
entre estas unidades ya que dicho aspecto es meramente visual y, al carecer de
interfaz gráfica, no será necesario. Cada uno de los jugadores dispondrá de un número
limitado de ejércitos o Infantería con valor 1 de ejército.
Figura 3 – Figuras del juego Risk
Escuela Técnica Superior de Ingeniería (ICAI)
Página 54
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
Las cincuenta y cuatro cartas de Risk
Cuarenta y dos marcadas con un territorio, y un dibujo de un soldado de
infantería, caballería o artillería ydoce cartas para usar en Risk: Misión Secreta, una
expansión del juego. En el juego desarrollado para la aplicación cada una de las cartas
marcadas con un territorio se considera un recurso con su correspondiente país y la
figura que tiene representada.Las cartas de misión u objetivo se considerarán un tipo
de recurso. Cada uno de los jugadores recibirá una carta de misión cuyo
funcionamiento se explicará más adelante.
Objetivo del Juego
El principal objetivo del juego es conquistar el mundo, ocupando los 42
territorios del tablero y, por lo tanto, eliminando a todos los oponentes.
Organización
A diferencia de la mayoría de los juegos, el RISK requiere planear la estrategia
que se va a utilizar durante la partida antes de comenzarla. La ubicación inicial de los
ejércitosserá crucial para conseguir uno de los objetivos del juego.
Se Selecciona un color y dependiendo del número de jugadores, toma los
ejércitos que se requieren para comenzar el juego.

Si son 3 jugadores: 35 ejércitos cada uno

Si son 4 jugadores: 30 ejércitos cada uno

Si son 5 jugadores: 25 ejércitos cada uno

Si son 6 jugadores: 20 ejércitos cada uno
En el juego desarrollado los jugadores no se diferenciarán por un color sino que
se les asignará un identificador distinto.
Escuela Técnica Superior de Ingeniería (ICAI)
Página 55
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
Empezando por la izquierda del primer jugador, todos, en turnos, colocan un
ejército en un territorio desocupado, se continúa hasta que los 42 territorios
hayan sido ocupados.
Puesto que esta elección no afecta al juego en sí, el juego colocará
automáticamente en los territorios ocupados por cada jugador una unidad hasta
completar los cuarenta y dos territorios.
Después de que los 42 territorios fueron ocupados, cada jugador en su turno
coloca un ejército adicional hasta que todos hayan quedado sin armadas de las
seleccionadas inicialmente. No hay límite del número de ejércitos que puede
haber en cada territorio.
Turno del jugador
Cada uno de los turnos de un jugador consiste en los siguientes pasos:
Refuerzo y ubicación de nuevos ejércitos
Al principio de cada turno, la aplicación calcula cuantos nuevos ejércitos le
corresponden al jugador en función del número de territorios y los continentes que
controla.
El número de territorios que ocupa: Al principio de cada turno la aplicación
contabiliza el número de territorios que ocupa el jugador, lo dividirá entre tres
descartando la fracción y el resultado es el número de ejércitos que recibe. El
jugador podrá colocar las unidades en cualquier territorio que posea.
El valor de los continentes que controla: El control de un continente es la
ocupación de todos los territorios que componen al mismo (ver la descripción de
cada continente junto a sus territorios en el apartado Tablero). Al inicio del turno
se recibirán ejércitos por cada continente bajo control de un jugador.Éste podrá
colocar las unidades en cualquier territorio que posea.
El valor de los tríos de Tarjetas RISK que cambies: Al final de cualquier
turno en el que se haya conquistado uno o varios territorios nuevos, se ganara
Escuela Técnica Superior de Ingeniería (ICAI)
Página 56
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
una carta RISK. Si se tiene un conjunto de 3 Tarjetas Risk con la misma división
militar (Infantería, Caballería, Artillería) se puede cambiar por ejércitos al inicio
del siguiente turno, o se puede esperar. Conforme se canjeen más tríos de
tarjetas RISK, más ejércitos recibirá un participante de acuerdo al número de
canjes que se han hecho durante la partida por cualquiera de los jugadores del
tablero. La tabla de cambios es la siguiente:
o 4 ejércitos con el primer cambio realizado por cualquier jugador.
o 6 ejércitos con el segundo cambio realizado por cualquier jugador.
o 8 ejércitos con el tercer cambio realizado por cualquier jugador.
o 10 ejércitos con el cuarto cambio realizado por cualquier jugador.
o 12 ejércitos con el quinto cambio realizado por cualquier jugador.
o 15 ejércitos con el sexto cambio realizado por cualquier jugador.
o Después del sexto cambio, el número de ejércitos aumentara en múltiplos
de 5. Para llevar esta cuenta la aplicación llevará un contador por cada
jugador que irá aumentando conforme se vayan realizando los cambios
de cartas por unidades.
El territorio específico mostrado en una carta canjeada: si una de las tres
tarjetas RISK que se cambia muestra la imagen de un territorio que ocupas, se
recibirá dos ejércitos extras.
Ataque
Después de colocar los ejércitos al principio del turno, se decide si se desea
atacar. El objeto del ataque es capturar un territorio al eliminar a los ejércitos del
enemigo en ese territorio. Las batallas se dan por medio de los dados.
Si se decide no atacar se pueden fortificar territorios, si así se desea. Si se decide atacar,
se deben seguir estas reglas:
Solo se puede atacar a un territorio que esta adyacente a un territorio propio.
Ejemplos: Groenlandia puede atacar a los Territorios del Noroeste, Ontario,
Quebec e Islandia. África del Norte puede atacar a Egipto, Europa del Oeste y
Brasil.
Escuela Técnica Superior de Ingeniería (ICAI)
Página 57
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
Se debe tener al menos 2 ejércitos en el territorio desde el cual se atacara.
Se puede continuar atacando un territorio hasta que hayan sido eliminados todas
las armadas enemigas en él, o se puede cambiar el territorio al que se ataca por
otro. Se pueden realizar todos los ataques que se deseen durante el turno.
Para atacar, primero se indica con qué territorio ataca, y cual es atacado, después
los jugadores tiran los dados, avisando previamente cuantos dados van a tirar y
lanzándolos al mismo tiempo. El atacante podrá tirar 1, 2 ó 3 dados, teniendo en cuenta
que debe tener al menos un ejército más que el número de dados que desea tirar. Por
otro lado, el defensor tirará 1 ó 2 dados, aunque para poder tirar dos dados deberá tener
al menos 2 ejércitos en su territorio. En ambos casos, mientras más dados lancen, más
posibilidades tienen de ganar pero, a la vez, más armadas pueden perder.
Para decidir el resultado de una batalla, se compara el dado más grande de cada
jugador, si el número del dado del atacante es mayor, el defensor pierde una armada del
territorio atacado. Pero si el dado del defensor es más grande, el atacante pierde una
armada. Si ambos tiraron más de un dado, comparen ahora el segundo dado de cada
uno, y repitan el proceso. En caso de empate, el defensor se ve favorecido y, por último,
ningún jugador puede perder más de dos armadas por cada tirada de dados.
Tan pronto como se elimina a la última armada enemiga en un territorio, se
considera capturado ese territorio y será ocupado inmediatamente. Para hacer esto el
atacante podrá mover tantas tropas como desee al territorio ocupado, como mínimo una
unidad. En la mayoría de los casos mover tantas armadas como se pueda es lo más
ventajoso, porque las armadas dejadas atrás no pueden ayudar en un nuevo ataque.
Finalmente, durante el juego todos los territorios deben estar ocupados al menos por una
armada.
Se puede terminar el ataque de un jugador en cualquier momento, si así lo desea.
Si se capturó al menos un territorio, el jugador tomará una carta Risk de la baraja.
Fortificar
Antes de terminar su turno, un jugador puede fortificar sus posiciones sobre
el campo de batalla, moviendo tantas armadas como desee desde un territorio de origen
Escuela Técnica Superior de Ingeniería (ICAI)
Página 58
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
hacia un territorio adyacente (colindante). Una vez hecho esto el turno del jugador habrá
finalizando pasando al siguiente jugador.
Escuela Técnica Superior de Ingeniería (ICAI)
Página 59
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
6.3 Diseño del Risk
Para la adaptación del juego de mesa Risk al motor desarrollado se han tenido que
tomar unas consideraciones previas y un estudio detallado del diseño a utilizar. A
continuación se detallarán las consideraciones previas tomadas:
Puesto que el motor carece de apartado gráfico cualquier acción que necesite de
visualización del mapa por parte del jugador tendrá que ser detallada
literalmente a través de la consola. Por ejemplo, a la hora de atacar un país el
jugador debe de conocer los países que son colindantes a los suyos, a qué
jugador pertenecen y el número de unidades enemigas que poseen.
El Risk tiene numerosas versiones que alteran o añaden nuevas reglas al juego.
Para el juego que se ha desarrollado se han utilizado las reglas del juego de
acuerdo a la última edición estadounidense de 2004.
Se aplicarán al juego todas las reglas descritas en dicha edición adaptándolas
cuando sea necesario y teniendo en cuenta las ausencia de gráficos del motor
intentando que la interacción del jugador con el juego sea lo más intuitiva y
sencilla posible.
Después de estas consideraciones se procedió al diseño del juego para su
adaptación al motor desarrollado. En primer lugar se procedió a definir los distintos
elementos del juego en función a las reglas especificadas en el punto 6.2. A
continuación se puede observar una tabla donde se indican los diferentes elementos
identificados y clasificados.
Escuela Técnica Superior de Ingeniería (ICAI)
Página 60
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
Después de tener identificados los diferentes elementos se desarrolló un
diagrama de flujo del turno de un jugador indicando los diferentes estados por los que
podría pasar durante una partida.
Figura 4 – Diagrama de Flujo Risk
Al comienzo del turno el primer estado al que puede acceder un jugador es el de
“Refuerzo”. En este estado se calcularán las unidades que le corresponden al jugador en
función del número de territorios conquistados y de los continentes que abarque. El
jugador podrá colocar dichas unidades en sus territorios para reforzar sus ejércitos.
A continuación, el jugador podrá optar por tres opciones: “Atacar país”,
“Cambiar cartas”, “Mover tropas” o bien “Finalizar el turno”.
Si la opción elegida es “Atacar país” el jugador podrá atacar un país de otro
jugador que sea adyacente a uno de los suyos siempre y cuando disponga de más de dos
unidades. En caso de querer continuar atacando más países del mismo jugador o de otro
podrá hacerlo hasta que decida saltar a otro estado. Desde este estado podrá ir al estado
de “Mover tropas” o bien “Finalizar el turno”.
Escuela Técnica Superior de Ingeniería (ICAI)
Página 61
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
En el estado “Cambiar cartas” el jugador podrá intercambiar las cartas que tenga
en la mano por nuevas unidades para asignar a sus territorios. A continuación podrá
saltar a los estados de “Atacar país”, “Mover tropas” o “Finalizar el turno”.
En el estado de “Mover tropas” el jugador podrá desplazar sus tropas a un
territorio adyacente de su propiedad para reforzar sus defensas estratégicas. Esta acción
podrá realizarla cuantas veces quiera hasta que dé por finalizado el desplazamiento.
Desde este estado podrá desplazarse al estado de “Fin de turno”.
Por último, en el estado de “Fin de turno” el juego comprobará las condiciones
de victoria y derrota. En el caso del Risk comprobará si cumple con los objetivos de la
carta Misión Secreta o si ha eliminado a todos los jugadores. En caso de cumplirse
alguno de los puntos se considerará ganador de la partida.
Teniendo identificados tantos los elementos del juego como los estados por los
que puede pasar un jugador se desarrollaron las diferentes reglas o acciones del juego. A
continuación se puede observar una tabla con las diferentes acciones que se
identificaron y una pequeña descripción de cuál es su función.
Acción
Refuerzo de batallón
Descripción
Esta acción consistirá en asignarle al jugador
las unidades que le correspondan en función
de los territorios y continentes ocupados.
Movimiento de tropas
Permitirá el movimiento de tropas de un
territorio a otro colindante del mismo jugador.
Información de Jugador
Puesto que el jugador no dispondrá de una
opción gráfica para observar sus unidades,
estructuras, etc. Esta clase permitirá mostrar
por consola toda la información del jugador.
Cambio de cartas
Esta acción permitirá el intercambio de cartas
por parte de un jugador por unidades que
podrá colocar en sus territorios.
Atacar un país
Esta acción consiste en poder atacar un
territorio enemigo colindante
Escuela Técnica Superior de Ingeniería (ICAI)
Página 62
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
Escuela Técnica Superior de Ingeniería (ICAI)
Página 63
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
7. Planificación
Escuela Técnica Superior de Ingeniería (ICAI)
Página 64
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
Para el desarrollo de este proyecto se ha seguido una metodología SCRUM. Se
han realizado entregas periódicas cada semana o dos semanas en función de la carga de
trabajo y disponibilidad del proyectante de los diferentes módulos desarrollados
permitiendo obtener logros medibles para la evaluación de la evolución del proyecto y
permitiendo adaptar cambios que surgían durante el desarrollo del trabajo de una forma
más sencilla.
A continuación se muestran las personas que han formado parte de este proyecto
y sus respectivos roles.
Figura 1 – Organigrama componentes del proyecto
En la primera etapa del proyecto se han identificado las necesidades y
oportunidades de desarrollar este proyecto y se han observado los beneficios de
desarrollarlo frente a otros programas existentes. Durante esta etapa también se ha
Escuela Técnica Superior de Ingeniería (ICAI)
Página 65
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
realizado un estudio del estado del arte estudiando otros proyectos similares y
estudiando las posibles ventajas que podría aportar nuestro proyecto.
Durante la etapa del análisis de requisitos se han estudiado los requisitos que
debe cumplir la aplicación y los objetivos que debía de conseguir.
A continuación, en la fase de diseño,se han estudiado los diferentes lenguajes
que se van a utilizar en el desarrollo de la aplicación así como las aplicaciones que se
utilizarían para su programación. Tras una primera fase de diseño lógica de la aplicación
se han desarrollado las reglas y estados por los que transcurre el juego de mesa Risk en
formato XML.Utilizando la herramienta Rational Software Architect se ha desarrollado
el diagrama de clases de la aplicación en UML y se ha convertido a código C++.
En la etapa de programación se han desarrollado y plasmado todos los requisitos
y diseños realizados anteriormente utilizando las diferentes herramientas mencionadas
anteriormente. Esta etapa se ha separado en diferentes subtareas.
Programación del kernel: En esta subtarea se ha desarrollado el núcleo de
la aplicación que será el encargado de toda la lógica de ésta. Esta subtarea se
ha realizado utilizando el lenguaje de programación C++. Para su desarrollo
de han utilizado los diagramas creados en el apartado 5.
Programación del modelo de juego: Se han desarrollado todos los ficheros
necesarios con la información del juego sin aún centrarse en el juego Risk.
Se han creado los esqueletos de los ficheros para que puedan ser utilizados
por cualquier desarrollador de juegos para este motor.
Integración con Python: En esta etapa se han integrado las reglas
desarrolladas en Python con la aplicación desarrollada en C++. Para ello se
ha utilizado la librería boost de C++ y Python (3.3.1).
Programación del juego real Risk: Se han desarrollado las reglas del juego
Risk mediante el lenguaje Python para validar la aplicación. A continuación
se definieron los diferentes estados por los que puede pasar el turno de un
jugador y que serán los encargador de invocar las diferentes reglas del juego
en función del estado en que se encuentre el jugador.
Escuela Técnica Superior de Ingeniería (ICAI)
Página 66
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
Se han realizado pruebas al final de la etapa de programación de las diferentes
subtareas mencionadas anteriormente para validar su funcionamiento. Por último, se ha
creado la documentación oficial del Proyecto a partir de todos los documentos que se
desarrollaron de diseño, arquitectura, etc.
A continuación se muestra un Diagrama de Gantt que muestra la planificación
que se ha ido siguiendo durante todo el desarrollo del proyecto.
Figura 2 – Diagrama de Gantt
Escuela Técnica Superior de Ingeniería (ICAI)
Página 67
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
8. Estudio Económico
Escuela Técnica Superior de Ingeniería (ICAI)
Página 68
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
8.1 Introducción
En este capítulo se muestra la estimación económica para el correcto desarrollo
del proyecto.
Existen dos separaciones para el cálculo del coste del desarrollo en función al
personal necesario para el desarrollo del sistema y el equipo hardware y software
utilizado.
Escuela Técnica Superior de Ingeniería (ICAI)
Página 69
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
8.2 Coste de Personal
A continuación se muestra el coste imputable a cada rol que ha participado en el
proyecto.
Rol
Horas trabajadas
Coste por hora
Coste Total
Coordinador
35
35 €
1.225 €
Director
140
28 €
3.920 €
Jefe de Proyecto
170
20 €
3.400 €
Programador y
220
15 €
3.300 €
desarrollador del
juego
11.845 €
Tabla1 – Coste de Personal
Escuela Técnica Superior de Ingeniería (ICAI)
Página 70
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
8.3 Coste de Hardware/Software
En cuanto a los costes por hardware se ha imputado el coste de un ordenador
portátil utilizado por el programador para el desarrollo de la aplicación. Todo el
software utilizado ha sido bajo licencia de estudiante o bien de licencia gratuita.
Concepto
Unidades
Coste Unitario
Total
Ordenador Portatil
1
900 €
900 €
ASUS 17’’ Windows
7
900 €
Escuela Técnica Superior de Ingeniería (ICAI)
Página 71
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
8.4 Conclusión
El coste total del proyecto asciende a 12.745 €. Este coste corresponde casi en su
mayoría al coste del personal que se ha empleado para el desarrollo del trabajo. El único
software propietario que se ha utilizado es el Microsoft Windows 7 que venía incluido
en el coste del portátil utilizado.
Gracias a que se ha utilizado software con licencia gratuita o bien con licencia
de estudiante los costes del producto se han visto significativamente reducidos con
respecto al coste en caso de haber utilizado productos propietarios o bien con licencia de
pago.
Escuela Técnica Superior de Ingeniería (ICAI)
Página 72
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
Escuela Técnica Superior de Ingeniería (ICAI)
Página 73
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
9. Conclusiones y
trabajos futuros
Escuela Técnica Superior de Ingeniería (ICAI)
Página 74
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
9.1 Conclusiones
A continuación se enumeran a modo de resumen las conclusiones a las que se
han llegado con la elaboración de este proyecto.
Menor complejidad a la hora de desarrollar juegos gracias al uso de Python
y XML.
o
El uso del lenguaje Python para la definición de las reglas del juego
reduce considerablemente la complejidad del desarrollo del juego
permitiendo a los creadores de juegos el desarrollo de estos sin
tener unos conocimientos muy elevados de programación.
o
Gracias al lenguaje etiquetado de XML es posible definir tanto los
recursos, estructuras, unidades, información del juego y el conjunto
de estados que conforman el turno de un jugador de una forma
sencilla e intuitiva pudiendo ser modificados en poco tiempo.
La comunicación entre los diferentes lenguajes es rápida y fluida sin afectar
al rendimiento del juego.
o
La lectura de archivos XML por parte del Kernel de la aplicación es
llevada a cabo rápidamente sin notar al comienzo del juego el
tiempo empleado para obtener la información sobre el juego.
o
A la hora de invocar cada una de las reglas del juego codificadas en
Python desde el módulo Kernel hecho en C++ se produce con una
total transparencia para el usuario final sin llegar a notar que el
juego está cambiando de un lenguaje a otro durante su ejecución.
La abstracción de objetos permite el desarrollo de juegos de mayor o
menos complejidad.
o
Gracias a la abstracción de clases que se ha realizado en el
desarrollo del Kernel de la aplicación su funcionamiento no está
condicionado a la complejidad del juego ya que la información está
correctamente distribuida.
o
Puesto que la gestión de las diferentes fases por las que pasa un
turno de un jugador se ha realizado mediante un diagrama de
Escuela Técnica Superior de Ingeniería (ICAI)
Página 75
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
estados la complejidad de un juego no afectará al transcurso de este
ya que se podrá dividir un turno de un jugador en tantos estados
como el desarrollador desee.
Al ser juegos interpretados, únicamente es necesario modificar el programa
intérprete para que el mismo juego funcione en diferentes plataformas.
Escuela Técnica Superior de Ingeniería (ICAI)
Página 76
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
9.2 Trabajos Futuros
En cuanto a trabajos futuros, en el campo de juegos para ordenador existen
muchas posibilidades de mejora para esta aplicación.
Desarrollo de una Inteligencia Artificial: Esta mejora permitiría jugar
partidas contra una Inteligencia Artificial que se pudiese adaptar a los
diferentes juegos que se desarrollasen para la aplicación. En función del
diagrama de estados de los turnos del jugador se podrían realizar partidas
de uno o varios jugadores contra una o varias inteligencias artificiales.
Desarrollo de la Interfaz Visual: Para realizar unos juegos más amigables
para los usuarios finales sería deseable desarrollar un módulo Visual para la
aplicación. Este módulo podría ser en un principio en dos dimensiones
utilizando la librería SDL o bien en tres dimensiones utilizando motores
gráficos ya desarrollados como por ejemplo el Ogre3D.
Desarrollo de las Comunicaciones: Por último, se podría desarrollar un
módulo de comunicaciones que permitiese partidas entre varios jugadores
que no compartiesen el mismo ordenador. Dichas partidas podrían ser o
bien en una red LAN o partidas por Internet mediante la compartición de la
IP de los diferentes jugadores.
Escuela Técnica Superior de Ingeniería (ICAI)
Página 77
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
10 Bibliografía
Escuela Técnica Superior de Ingeniería (ICAI)
Página 78
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
10.1 Bibliografía
[PELL92]
Barney Pell.
University
of
Cambridge.
METAGAME: A new challenge for Games
and Learning.
[GUIJ10]
Victor Guijarro. La quimera del autómata
matemático: del calculador medieval a la
máquina analíticade Babbage.
[TINY12]
http://www.grinninglizard.com/tinyxml/
[BOOS12]
http://www.boost.org/
[UNRE12]
http://www.unrealengine.com/
[CTUT12]
http://www.cplusplus.com/doc/tutorial/
[DEIT98]
H. M. Deithel – P. J. Deithel. Como
programar en C/C++ (Prentice Hall)
[PYTH12]
Escuela Técnica Superior de Ingeniería (ICAI)
http://www.python.org/
Página 79
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
Anexo 1
Manual de Instalación
Escuela Técnica Superior de Ingeniería (ICAI)
Página 80
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
Instalación Python
Para el correcto funcionamiento de la aplicación es necesario instalar el
intérprete del lenguaje de programación Python para poder leer correctamente las reglas
de los juegos. A continuación se puede ver una pequeña guía de instalación de Python
bajo el sistema operativo Windows. Existen dos versiones estables de Python
disponibles: Python 2 y Python 3. Se aconseja instalar la versión 2 ya que la aplicación
ha sido desarrollada utilizando la versión Python 2 aunque con la versión 3 no debería
de existir ningún problema.
El primer paso será comprobar que no existe una versión de Python instalada
anteriormente. Para ello se debe de abrir una ventana de consola y escribir “python”. Si
se recibe una respuesta de un intérprete de Python ésta incluirá el número de versión.
Como ya se ha comentado anteriormente, por regla general las versiones más recientes
de Python mantienen compatibilidad con las versiones antiguas. En caso de no recibir
respuesta no existe ningún intérprete instalado en la máquina.
Figura 1 – Consola de Comandos Windows
Para la instalación de Python es necesario descargarse de la página oficial una
versión estable. Dicho instalador consiste en un Wizard amigable en el cual se deberá de
indicar la ruta donde se instalará Python y los paquetes que se instalarán. Se recomienda
descargar la versión estable más reciente e instalar como mínimo los paquetes
Escuela Técnica Superior de Ingeniería (ICAI)
Página 81
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
recomendados. Para el desarrollo de la aplicación se ha utilizado la versión Python 2.9
aunque cualquier versión posterior funcionará. El instalador puede descargarse desde la
página oficial: http://www.python.org/download/
Instalación Boost Library
Es recomendable utilizar el instalador que proporciona la página oficial de Boost
(http://www.boost.org) en caso de utilizar Microsoft Visual Studio para su uso ya que el
instalador descarga e instala los binarios precompilados sin necesidad de tener que
construirlos. La única librería necesaria para el correcto manejo de boost es la librería
“BoostPython” tal y como puede verse en la imagen.
Figura 2 – BoostPython
Escuela Técnica Superior de Ingeniería (ICAI)
Página 82
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
Tras concluir la instalación se tendrá en la carpeta donde se haya decidido
instalarlo la siguiente estructura de directorios:
boost_1_49_0\ .................el directorio raiz de Boost
index.htm .........una copia de la página www.boost.org
boost\ .........................Todas las cabeceras de Boost
lib\ .....................Binarios de las libreríasprecompilados
libs\ ............Tests, .cpps, docs, etc., ordenador por librería
index.html ........documentación de las librerías
algorithm\
any\
array\
…más librerías…
status\ .........................Boost-wide unidad de test
tools\ ...........Herramientas, ejemplo. Boost.Build, quickbook.
more\ ..........................Ficheros de licencia, etc.
doc\ ...............Toda la documentación necesaria para boost.
Escuela Técnica Superior de Ingeniería (ICAI)
Página 83
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
Localización ficheros XML y .py
Tanto los ficheros XML con la información del juego como los ficheros Python
con las reglas de éste deben de estar correctamente situados para que la aplicación
pueda encontrarlos. Existe una carpeta llamada “recursos” dentro de la aplicación que es
donde deben de situarse todos estos ficheros, en especial los archivos XML,
inijuego.py y finjuego.py.
Figura 2 – Carpeta recursos
El resto de archivos .py pueden ir en cualquier otra ruta aunque deberá de ser
correctamente indicada en el fichero estados.xml para que la aplicación pueda
encontrarlos correctamente
Escuela Técnica Superior de Ingeniería (ICAI)
Página 84
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
Escuela Técnica Superior de Ingeniería (ICAI)
Página 85
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
Anexo 2
Manual de Usuario
Escuela Técnica Superior de Ingeniería (ICAI)
Página 86
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
Estructura de Ficheros XML
Para el correcto funcionamiento de la aplicación, los ficheros XML utilizados
para la Información del Juego deben de seguir una estructura prefijada. Dicha estructura
cumple los estándares de la versión 1.0 del lenguaje XML. Dicha versión es una
recomendación del W3C (World Wide Web Consortium) desde Febrero de 1998 y que
se sigue utilizando actualmente. La nomenclatura tanto del propio fichero XML como
de las etiquetas que lo conforman debe de respetarse excepto aquellas etiquetas en las
que se indique lo contrario.
Estados.xml
estados.xml
<?xmlversion=”1.0” ?>
<estados>
<elem>
<id>id_estado</id>
<name>nombre_estado</name>
<acciones>
<auto>
<nombre>nombre_accion</nombre>
<funciones>
<funciones_ext>fichero_python</funciones_ext>
</funciones>
</auto>
<salto>
<salto_estado>id_estado_salto</salto_estado>
<nombre>nombre_estado_salto</nombre>
</salto>
</acciones>
</elem>
</estados>
El fichero estados.xmles el encargado de indicar a la aplicación los diferentes
estados por los que podrá discurrir el turno de un jugador y los posibles saltos de uno a
otro. En primer lugar, como en cualquier fichero XML, está la etiqueta
<?xmlversión=”1.0” ?>. Esta etiqueta sirve para que la aplicación sepa que el fichero
que va a procesar se trata de un fichero XML de la versión 1.0.
Escuela Técnica Superior de Ingeniería (ICAI)
Página 87
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
Cada uno de los diferentes estados que conforman el turno de un jugador se
indicará dentro de la etiqueta <elem></elem>. Dichas etiquetas se representarán dentro
de la etiqueta global <estados></estados>. Por lo tanto, existirán tanta etiquetas
<elem> como estados tenga el turno de un jugador.
Cada estado tendrá diferentes atributos obligatorios. Estos atributos se pueden
dividir en dos bloques. En primer lugar, los atributos referentes a la identificación del
estado. El primer identificador tiene que ser numérico y único y se plasmará con la
etiqueta <id></id>. El primer estado que la aplicación tratará de ejecutar será el estado
con id 0. El segundo identificador del estado es el nombre que se mostrará durante la
partida. Este nombre no tiene que ser necesariamente único aunque es recomendable
para evitar confusiones entre estados, aunque es posible que en algún tipo de juego sea
necesario sobrecargar estados que tengan el mismo nombre pero que su comportamiento
tenga alguna variación. El nombre del estado irá en la etiqueta <name></name>.
En segundo lugar es necesario indicar a la aplicación qué acciones deben de
realizarse durante este estado y los posibles saltos permitidos. Esta información irá
encapsulada
en
la
etiqueta
<acciones></acciones>.
Dentro
de
la
etiqueta
<auto></auto> se indicarán las acciones automáticas que se dispararán nada más entrar
el jugador en este estado del juego. Se indicará el nombre de la acción entre la etiqueta
<nombre></nombre> y el fichero Python que se tendrá que ejecutar entre las etiquetas
<funciones><func_ext></func_ext></funciones>. El fichero Python tendrá que estar
en el mismo directorio que el fichero XML y será de la forma nombre_fichero.py.
Por último es necesario indicar los posibles saltos que se pueden producir desde
ese estado a otros. Estos saltos se indicarán mediante la etiqueta <salto></salto>.
Existirán tantas etiquetas <salto> como saltos puedan realizarse desde ese estado. Esta
etiqueta tendrá dos atributos: En primer lugar el identificador del estado al que puede
saltarse con la etiqueta <salto_estado></salto_estado> y en segundo lugar el nombre
del estado al que se salta con la etiqueta <nombre></nombre>. Este nombre será el
que se muestre durante el juego para que el jugador elija la opción de salto.
El estado final es considerado aquel que no tiene información alguna asignada
por lo que es recomendable que en el último estado del jugador exista un salto final a
otro estado, “Fin de turno”, con un identificador aún no asignado.
Escuela Técnica Superior de Ingeniería (ICAI)
Página 88
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
juego.xml
juego.xml
<?xmlversion=”1.0” ?>
<propiedades>
<nombre>nombre del juego</nombre>
<numJugadores>número de jugadores</numJugadores>
<atributo>otros atributos</atributo>
</propiedades>
El fichero juego.xmles el encargado de indicar a la aplicación las características
del juego. En primer lugar, como se ha comentado en los anteriores ficheros XML, está
la etiqueta <?xml versión=”1.0” ?>. Esta etiqueta sirve para que la aplicación sepa que
el fichero que va a procesar se trata de un fichero XML de la versión 1.0.
A continuación existen dos atributos que son obligatorios para todo juego que
quiera ejecutarse en la aplicación. Todos los atributos irán incluidos dentro de la
etiqueta <propiedades></propiedades>.
El primer atributo obligatorio es el nombre del juego. Este nombre se utilizará
para mostrarlo durante la partida. Irá dentro de la etiqueta <nombre></nombre>. El
segundo atributo obligatorio es el número máximo de jugadores. Este número se
utilizará para que la aplicación pueda saber el rango de jugadores permitidos en la
partida. Irá dentro de la etiqueta <numJugadores></numJugadores>.
A continuación se indicarán el resto de atributos del juego que son particulares e
innatos a él. El nombre de la etiqueta puede ser cualquiera y su contenido puede ser
tanto numérico como una cadena de texto.
Escuela Técnica Superior de Ingeniería (ICAI)
Página 89
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
Recursos.xml
recursos.xml
<?xmlversion=”1.0” ?>
<recursos>
<elem>
<id>id_recurso</id>
<nombre>nombre_recurso</nombre>
<definicion>definicion_recurso</definicion>
<atributo>valor_atributo</atributo>
</elem>
</recursos>
El fichero recursos.xmles el encargado de indicar a la aplicación los diferentes
recursos de que dispone el juego y que podrán ser utilizados de forma directa o indirecta
por el jugador durante la partida. En primer lugar, como se ha comentado en el fichero
estados.xml, está la etiqueta <?xml versión=”1.0” ?>. Esta etiqueta sirve para que la
aplicación sepa que el fichero que va a procesar se trata de un fichero XML de la
versión 1.0.
Cada uno de los diferentes recursos que forman parte del juego se indicará
dentro de la etiqueta <elem></elem>. Dichas etiquetas se representarán dentro de la
etiqueta global <recursos></recursos>. Por lo tanto, existirán tanta etiquetas <elem>
como recursos tenga el juego.
Para la descripción de un recurso se utilizarán tres atributos fundamentales. El
primero de ellos será el identificador, el cual tendrá que ser numérico y único y se
plasmará con la etiqueta <id></id>. El segundo identificador del recurso es el nombre
que se mostrará durante el juego. Este nombre no tiene que ser necesariamente único
aunque es recomendable para evitar confusiones entre recursos. El nombre del recurso
irá en la etiqueta <nombre></nombre>. El último atributo fundamental es la
descripción o definición del recurso. Esta definición es una pequeña explicación sobre
el recurso e irá en la etiqueta <definicion></definicion>.
A continuación se indicarán el resto de atributos del recurso que son particulares
e innatos a él. El nombre de la etiqueta puede ser cualquiera y su contenido puede ser
tanto numérico como una cadena de texto. Por ejemplo en el caso del Risk, a la hora de
plasmar en el fichero el recurso “Continente”, podemos indicar los países que lo forman
mediante una etiqueta <países>.
Escuela Técnica Superior de Ingeniería (ICAI)
Página 90
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
Escuela Técnica Superior de Ingeniería (ICAI)
Página 91
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
estructuras.xml
estructuras.xml
<?xmlversion=”1.0” ?>
<estructuras>
<elem>
<id>id_estructura</id>
<nombre>nombre_estructura</nombre>
<definicion>definicion_estructura</definicion>
<atributo>valor_atributo</atributo>
</elem>
</ estructuras>
El fichero estructuras.xmles el encargado de indicar a la aplicación las
diferentes estructuras de las que dispone el juego y que podrán ser utilizadas de forma
directa o indirecta por el jugador durante la partida. En primer lugar, como se ha
comentado en los anteriores ficheros XML, está la etiqueta <?xml versión=”1.0” ?>.
Esta etiqueta sirve para que la aplicación sepa que el fichero que va a procesar se trata
de un fichero XML de la versión 1.0.
Cada una de las diferentes estructuras que forman parte del juego se indicará
dentro de la etiqueta <elem></elem>. Dichas etiquetas se representarán dentro de la
etiqueta global <estructuras></estructuras>. Por lo tanto, existirán tanta etiquetas
<elem> como estructuras tenga el juego.
Para la descripción de una estructura se utilizarán tres atributos fundamentales.
El primero de ellos será el identificador, el cual tendrá que ser numérico y único y se
plasmará con la etiqueta <id></id>. El segundo identificador de la estructura es el
nombre que se mostrará durante el juego. Este nombre no tiene que ser necesariamente
único aunque es recomendable para evitar confusiones entre estructuras. El nombre de
la estructura irá en la etiqueta <nombre></nombre>. El último atributo fundamental es
la descripción o definición de la estructura. Esta definición es una pequeña explicación
sobre la estructura e irá en la etiqueta <definicion></definicion>.
A continuación se indicarán el resto de atributos de la estructura que son
particulares e innatos a ella. El nombre de la etiqueta puede ser cualquiera y su
contenido puede ser tanto numérico como una cadena de texto.
Escuela Técnica Superior de Ingeniería (ICAI)
Página 92
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
unidades.xml
unidades.xml
<?xmlversion=”1.0” ?>
<unidades>
<elem>
<id>id_unidad</id>
<nombre>nombre_ unidad</nombre>
<definicion>definicion_ unidad</definicion>
<atributo>valor_atributo</atributo>
</elem>
</ unidades>
El fichero unidades.xml es el encargado de indicar a la aplicación las diferentes
unidades de las que dispone el juego y que podrán ser utilizadas de forma directa o
indirecta por el jugador durante la partida.
Cada una de las diferentes unidades que forman parte del juego se indicará
dentro de la etiqueta <elem></elem>. Dichas etiquetas se representarán dentro de la
etiqueta global <unidades></unidades>. Por lo tanto, existirán tanta etiquetas <elem>
como unidades tenga el juego.
Para la descripción de una unidad se utilizarán tres atributos fundamentales. El
primero de ellos será el identificador, el cual tendrá que ser numérico y único y se
plasmará con la etiqueta <id></id>. El segundo identificador de la unidad es el nombre
que se mostrará durante el juego. Este nombre no tiene que ser necesariamente único
aunque es recomendable para evitar confusiones entre unidades. El nombre de la unidad
irá en la etiqueta <nombre></nombre>. El último atributo fundamental es la
descripción o definición de la unidad. Esta definición es una pequeña explicación sobre
la unidad e irá en la etiqueta <definicion></definicion>.
A continuación se indicarán el resto de atributos de la unidad que son
particulares e innatos a ella. El nombre de la etiqueta puede ser cualquiera y su
contenido puede ser tanto numérico como una cadena de texto.
Escuela Técnica Superior de Ingeniería (ICAI)
Página 93
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
Estructura de Ficheros Python
Para el correcto funcionamiento de la aplicación, es necesario seguir una serie de
indicaciones para que el conjunto de reglas declaradas para el juego tengan validez y se
desarrolle correctamente la partida.
Existirán tantos ficheros Python como reglas se vayan a declarar en el juego.
Cada estado del juego dispondrá de al menos un fichero Python al que poder invocar
para ejecutar las acciones correspondientes al estado donde se encuentra. Estos ficheros
pueden repetirse por los diferentes estados pudiendo ser invocados desde dos estados
completamente diferentes aunque su comportamiento será el mismo por lo que esta
opción habrá veces que carezca de sentido.
Como ya se ha comentado anteriormente en el apartado de “Estructura de
Ficheros XML”, los ficheros Python tienen una extensión *.py la cual deberá de ser
indicada obligatoriamente a la hora de referenciarlos en el fichero estados.xml. La
nomenclatura del fichero es indiferente aunque se recomienda que sea descriptiva para
evitar confusiones.
Existen dos ficheros Python muy particulares que deben de existir
obligatoriamente aunque su contenido sea vacío.
Escuela Técnica Superior de Ingeniería (ICAI)
Página 94
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
Reglas generales para un fichero Python
Cualquier fichero Python que quiera hacer uso tanto de la información del juego
como de las funcionalidades que aporta el Kernel de la aplicación deberá de incluir la
siguiente línea al principio.
import jugador
Gracias a este import se podrán utilizar dentro del fichero Python todas las clases
definidas en la aplicación (jugadores, recursos, unidades, etc) y, por lo tanto, la mayoría
de los métodos inherentes a ellas. A continuación se indican los métodos que pueden
utilizarse dentro del fichero Python referentes a los objetos creados en C++.
Objetos globales:
jugadoractual: Identificador del jugador actual
jugadores: Vector con todos los jugadores de la partida
recursos: Vector con todos los recursos declarados en el fichero
recursos.xml.
unidades: Vector con todas las unidades declaradas en el fichero
unidades.xml.
estructuras: Vector con todas las estructuras declaradas en el
fichero estructuras.xml.
Métodos:
Jugador:
o setunidad(unidad): añade una unidad al jugador.
o setrecurso(recurso): añade un recurso al jugador.
o eliminarrecurso(posición): elimina un recurso del
jugador.
o getunidad(posición): devuelve una unidad del jugador.
o getrecurso(posición: devuelve un recurso del jugador.
o addunidadrecurso(recurso, unidad): añade una unidad a
un recurso del jugador.
o elimunidadrecurso(recurso, unidad): elimina una unidad
de un recurso del jugador.
o totalunidades(): devuelve el total de unidades del jugador.
o totalrecursos(): devuelve el total de recursos del jugador.
o setestado(estado): modifica el estado del jugador.
Escuela Técnica Superior de Ingeniería (ICAI)
Página 95
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
o getestado(): devuelve el estado del jugador.
Recurso:
o setdefinicion(definicion): añade una definición al recurso.
o getdefinicion(): devuelve la definición del recurso.
o gettipo(): devuelve el tipo de recurso.
o getposicion(): devuelve la posición del recurso.
o getnombre(): devuelve el nombre del recurso.
o getatributo(atributo): devuelve el valor del atributo
indicado.
o addunidad(unidad): añade una unidad al recurso.
o getunidad(posición): devuelve una unidad del recurso.
o eliminarunidad(posición): elimina una unidad del recurso.
o totalunidades(): devuelve el total de unidades que tiene el
recurso.
Estructura:
o setdefinicion(definicion): añade una definición a la
estructura.
o getdefinicion(): devuelve la definición de la estructura.
o gettipo(): devuelve el tipo de estructura.
o getposicion(): devuelve la posición de la estructura.
o getnombre(): devuelve el nombre de la estructura.
o getatributo(atributo): devuelve el valor del atributo
indicado.
Unidad:
o setdefinicion(definicion): añade una definición a la
unidad.
o getdefinicion(): devuelve la definición de la unidad.
o gettipo(): devuelve el tipo de unidad.
o getposicion(): devuelve la posición de la unidad.
o getnombre(): devuelve el nombre de la unidad.
o getatributo(atributo): devuelve el valor del atributo
indicado.
Vector Recursos:
o size(): tamaño del vector.
o Push_back(): introduce un recurso en el vector.
Vector Unidades:
o size(): tamaño del vector.
o Push_back(): introduce una unidad en el vector.
Vector Estructuras:
o size(): tamaño del vector.
o Push_back(): introduce una estructura en el vector.
Escuela Técnica Superior de Ingeniería (ICAI)
Página 96
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
Vector Jugadores:
o size(): tamaño del vector.
Otros módulos de Python
A continuación se listarán un conjunto de módulos optativos que pueden ser de
ayuda a la hora de programar las reglas del juego en Python. Para poder incluir estas
librerías se deberá de añadir en la cabecera del fichero:
importlibreria
Librería
Descripción
string
Operaciones con Strings
datetime
Tipos básicos de fechas y tiempo
collections
Tipos de datos de colecciones
math
Funciones matemáticas
random
Generar números pseudo-aleatorios
cmath
Funciones
matemáticas
para
números
complejos.
hashlib
Algoritmo hash para encriptación
xml.dom
API de DOM (DocumentObjectModel)
webbrowser
Controlador para navegador web
smtpd
Librería para gestionar servidor SMTP
audioop
Librería para la gestión de audio
imageop
Librería para la gestión de imágenes
pdb
PythonDebugger
zipimport
Importar módulos de archivos ZIP
Escuela Técnica Superior de Ingeniería (ICAI)
Página 97
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
Ficheros Python propios de la aplicación
Como se ha comentado previamente en la introducción del punto “Estructura de
Ficheros Python”, existen dos ficheros que son obligatorios para el correcto
funcionamiento de la aplicación. Estos ficheros pueden estar vacíos sin necesidad de
tener que ejecutar código alguno aunque es recomendable utilizarlos para el fin que se
explica a continuación.
inijuego.py
Este fichero es leído por el Kernel de la aplicación para inicializar todos los
objetos necesarios para el correcto funcionamiento del juego. En este módulo se
asignarán los recursos, estructuras y unidades iniciales a los jugadores, se describirán
las reglas del juego a los jugadores, etc. Inijuego.py se ejecutará después de leer los
ficheros XML con la información del juego y antes de comenzar la partida por lo que su
presencia es obligatoria. Se puede utilizar este archivo dentro de los estados del juego
para, por ejemplo, la entrada de un nuevo jugador durante la partida ya comenzada.
finjuego.py
Este fichero es leído y procesado por el Kernel de la aplicación al terminar el
turno de un jugador. Su misión es la de proporcionar al juego las reglas de victoria o de
fin de juego. Este archivo es obligatorio que exista aunque no es necesario que tenga
contenido alguno dentro ya que es posible que exista algún tipo de juego sin final
preestablecido. Para indicar que un jugador ha terminado la partida sólo será necesario
poner su estado a -1.
Escuela Técnica Superior de Ingeniería (ICAI)
Página 98
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
Escuela Técnica Superior de Ingeniería (ICAI)
Página 99
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
Anexo 3
Manual de
Desarrollador
Escuela Técnica Superior de Ingeniería (ICAI)
Página 100
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
Instalación Microsoft Visual Studio
2008
A continuación se explicarán los pasos necesarios para instalar el entorno de
desarrollo Microsoft Visual Studio 2008.
En primer lugar aparecerá la siguiente ventana para iniciar la instalación.
Figura 1 – Ventana de instalación
Después de hacer clic en “Instalar Visual Studio 2008, el instalador nos mostrará
la siguiente ventana:
Escuela Técnica Superior de Ingeniería (ICAI)
Página 101
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
Figura 2 – Asistente de instalación
Se puede marcar la opción de “Enviar a Microsoft Corporation información
sobre la instalación”. Esta opción sirve para mejorar el producto para que en caso de
producirse algún error durante la instalación o durante la ejecución del producto enviar
un mensaje a Microsoft Corporation.
A continuación, nos aparecerá la ventana en la que debemos de introducir el
código de licencia y nuestro nombre.
Figura 3 – Código de licencia
Escuela Técnica Superior de Ingeniería (ICAI)
Página 102
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
Después el programa de instalación nos pregunta qué se desea instalar.
Figura 4 – Opciones de instalación
Una vez completados estos pasos nos llevará a la ventana de progreso de instalación.
Figura 5 – Ventana de progreso
Escuela Técnica Superior de Ingeniería (ICAI)
Página 103
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
La instalación tardará varios minutos dependiendo de la máquina en la que se
instale y dependiendo de la opción que se haya marcado a la hora de instalar. Una vez
instalado nos aparecerá la siguiente ventana.
Figura 6 – Ventana de instalación completada
Escuela Técnica Superior de Ingeniería (ICAI)
Página 104
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
Configuración Boost y tinyXml
A continuación se explicarían los pasos necesarios para configurar las librerías
boost y tinyXml para su correcto funcionamiento en el entorno de desarrollo Microsoft
Visual Studio 2008.
En primer lugar hay que acceder a las Propiedades del proyecto pinchando en
Project ->Properties.
Figura 1 – Propiedades de un proyecto
Se abrirá una nueva ventana con todas las variables de configuración para
nuestro proyecto tanto para el modo Debug como el modo Release. Dependiendo del
modo que nos interese modificaremos una configuración u otra.
Escuela Técnica Superior de Ingeniería (ICAI)
Página 105
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
En
ConfigurationProperties->C/C++->General-
>AdditionalIncludeDirectories habrá que añadir tanto la librería boost como la de
Python tal y como se muestra en la imagen.
Figura 2 – AdditionalIncludeDirectories
Escuela Técnica Superior de Ingeniería (ICAI)
Página 106
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
A continuación hay que desplegar el apartado de Linker y entrar en
ConfigurationProperties->Linker->General->AdditionalLibraryDirectories.
En
este apartado hay que añadir tanto la librería boost como la de Python y tinyXml tal y
como se muestra en la imagen.
Figura 3 – Additional Library Directories
Escuela Técnica Superior de Ingeniería (ICAI)
Página 107
Antonio Jesús Berbel Rodríguez-Campra
Inteligencia de plataforma para el desarrollo de juegos por computador
Por último, para añadir la librería tinyXml hay que desplegar el apartado de
Linker
y
entrar
en
ConfigurationProperties->Linker->Input-
>AdditionalDependencies. En este apartado hay que añadir la librería tinyxmld.lib.
Figura 4 – AdditionalDependencies
Escuela Técnica Superior de Ingeniería (ICAI)
Página 108