Este documento introduce la herramienta de desarrollo de videojuegos Maratis. Explica conceptos clave como motores gráficos, físicos y matemáticos. Describe cómo descargar e instalar Maratis, y brevemente cómo usar su editor visual para crear escenas 3D y niveles. Sin embargo, enfatiza que para aprovechar todo el potencial de Maratis se requiere programación en C++.

1. INTRODUCCION
Cuando se trata de desarrollar un videojuego disponemos de muchas herramientas para llevar a cabo
su desarrollo que van desde donde hay que hacer todo en lineas de código hasta donde no hay que
codificar una tan sola linea. Pero bien si hablamos de multiplataforma nuestro amplio repertorio de
herramientas se reduce considerablemente y aun mas si nos reportamos como partidarios del
movimiento del software libre o no tenemos dinero para pagar potentes y versátiles pero caras
herramientas privativas. Seleccionar una de las herramientas que nos quedan aun permanecen en
lista luego de lo anterior dicho puede llegar a ser una molestia por razones que no voy a mencionar,
atravez de este documento se pretende conocer una útil herramienta para la grandiosa tarea de
desarrollar un videojuego.
Se le llama motor de juego o “Game Engine” a una a una serie de rutinas de programacion que
permiten el diseño, la creación y la representación de un videojuego. Estando dentro de esta
clasificacion tanto herramientas para diseñar videojuegos de manera gráfica mediante una interfaz
como aquellas que precisan de codificar todo manualmente.
CONCEPTOS INPORTANTES
Hace unos días escuché al alguien decir “Un videojuego es mas que solamente software” y pienso
que tiene toda la razón pues este es el punto de encuentro de muchas disciplinas que se unen para
darnos el producto final que tantas horas hemos pasamos disfrutando. Así que antes de ir a lo bueno
me tomaré un momento para explicarte algunos conceptos importantes.
Como ya sabemos un videojuego es una realidad alterna en la que nos sumergimos, pero lo de
realidad alterna no solo se queda en lo que nosotros vemos y hacemos con un control es nuestras
manos sino que es una simulación muy bien abstraída de la realidad.
Por lo general se hace una clasificación interna de un videojuego que costa de tres partes:
1. Motor Gráfico:
En la pieza que se encarga de la parte visual y la que hace que nos enamoremos de las altamente
realistas gráficas de muchos juegos, este por lo general trabaja con tres componentes que son la
geometría, la iluminación y las cámaras.
La geometría engloba todo esos objetos que vemos en pantalla y en
muchos casos cosas que no son en si objetos como ser destellos de
luz, fuego, humo etc.
Un objeto es una porción de geometría con una forma especifica,
puede ser una silla,un automóvil, un puerta, un personaje etc.
Estos objetos están compuestos por polígonos en una espacio de tres
dimensiones y se la cantidad del que ese compone el objeto(Low
Poly, High Poly) ya que entre mas polígonos mayor cantidad de
detalle puede llegar a tener el objeto.
Las texturas son imágenes que acompañan a los objetos, estas se mapean sobre la superficie del
objeto para simular materiales del mundo real.

2. Existen varios formas de usar una textura en un objeto 3D, el metodo que es usado desde tiempos
inmemoriales es el Diffuse en el cual la imagen simplemente se estampa en la superficie del objeto,
otros metodos mas recientes son el Normal map y el Specular map donde se usan imagenes para
simular que el objeto posee un relieve y que también refleja la luz que recibe.
Una lampara es una fuente de luz en una escena 3D y se comporta exactamente como una lampara
en la vida real, dependiendo del motor grafico son los tipos de lamparas que se pueden crear, la mas
comun es la de punto u omnidireccional la cual la luz nace de un solo punto y se dispersa en todas
las direcciones y rara vez produce sombras, otra es la de tipo spot que se comporta como una
lampara de mano y es la que por excelencia produce sombras.
Por ultimo la cámara, aunque esta no necesita mucha explicacion, es lo mismo que una camara en
la vida real e incluso en algunos motores tienen exactamente la mismas configuraciones que una
real. Atravez de ella vemos el mundo 3D que hemos creado.
Todo esto y algunos otros aspectos que no he mencionado se unen para llegar a una etapa conocida
como render. Que es el proceso de pintar en pantalla el mundo virtual que hay en la memoria del
computador, este proceso ocurre varias veces por segundo para poder crear una secuencia animada
de la misma manera en que se hacen los dibujos animados.
2. Motor Matemático y Motor Físico:
Los pongo juntos porque van de la mano y yo personalmente los considero como una sola cosa. El
motor físico es el que se encarga de que los objetos en la escena reaccionen de forma realista ante
fuerzas externas como ser explosiones, empujones, disparos y golpes! El motor Matemático es el
que se encarga de como el motor físico hace estas simulaciones, acá es donde empieza la parte nerd
de hacer un videojuego porque todo eso que te enseñaban en las clases de matemáticas y física a las
cuales no prestabas atención se hace útil y necesario.
Se puede hablar de el motor de IA(inteligencia artificial) y del motor de audio, pero el primero
puede fácilmente quedar englobado dentro de lo que es el motor matemático y la parte del audio por
lo general es solo audio pregrabado que se reproduce y en algunos casos se le aplica algún efecto en
tiempo real.
AHORAA LO BUENO...
Ahora vamos a lo importante y la razon por la que lees esto, a partir del resto de este documento te
enseño lo necesario para que empieces a desarrollar tus videjuegos con Maratis y C++ advierto
desde ahora que si no eres un programador y lo que buscas es desarrollar un juego tocando botones
estas en el sitio equivocado puesto que este es un documento dirigido para programadores que están
relacionados con C++ y la programación orientada a objetos.

3. Yo hago uso de Ubuntu 14.04 al hacer este pequeño manual pero el proceso aplica a Windows con
algunas diferencias, lo que haya que instalar lo iré explicando mas adelante.
Me falto mencionar que Maratis es un motor de videojuegos que a pesar de su sencillez ha
demostrado ser muy potente, es código abierto y plataforma.
Sin mas preámbulos conoscamoslo, vamos a su pagina oficial: http://www.maratis3d.org/
Podemos ver una reseña del programa y notamos que dispone una interfaz gráfica y muchos me
dirán: No acabas de decir “aquí no se hacen las cosas con botoncitos” los que quieran hacerlo así
váyanse, pues cabe aclarar una cosa: Maratis dispone de un editor visual para posicionar objetos 3D
en la escena y editar alguna opciones sobre los mismos, también se puede programar el
comportamiento en Lua pero de esta forma no estamos explotando el potencial del motor maratis
solo estamos accediendo a las capacidades de una pequeña parte de el y como dice allá arriba en la
reseña “obtener acceso total al motor con C++ ” pues voy a centrarme mas que nada en esto. Bueno
ahora que he dicho eso podemos continuar.
Váyase a la pestaña “Download” y buscamos la versión para nuestro So

4. # Estas son la versiones para diferentes plataformas
#El plugin para exportar objetos 3D desde blender
#El código fuente de maratis, mas tarde veremos porque es de importancia para nosotros
Luego descomprimimos el archivo que acabamos de bajar
Si estas usando Ubuntu 14.04 al igual que yo basta con que entres a la carpeta, luego a la carpeta
bin y le des doble click al archivo MaratisEditor

5. Si usas otra distribución de linux o una version de ubuntu anterior es posible que tengas que copiar
los archivos 'libMCore.so', 'libMEngine.so ' y 'libsndfile.so' a la carpeta usrlib o abrirlo por
consola para que el programa funcione.
EL EDITOR DE MARATIS
Aunque aprender a usar editor de maratis no es el objetivo de este material el uso del mismo puede
resultar nos útil por lo que le dedico una pequeña sección en este documento.
Lo primero será ir a file->new project y luego nos pedirá la carpeta donde queremos nuestro
proyecto.

6. yo lo he guardado en homearielproyectos y le he dado el nombre de MaratisPrueba, despues
entramos a la carpeta donde guardamos el proyecto y nos encontramos con esto:
Se crea un archivo con extensión .mproj y se crean varias carpetas, los nombres de las carpetas
hablan por si solos, en levels se guardan los niveles en formato XML con extensión .level, en meshs
se guardan los objetos 3D, en maps las se guardan las texturas y en scripts se guardan los archivos
de código de lua. Estas carpetas son de especial importancia para nosotros.
Ahora voy a enseñarte algunas herramientas básicas del editor de maratis:
herramientas:
2. Mover un objeto
3.Rotar un objeto
4.Escalar un objeto(cambiar tamaño)
5.añadir una cámara

7. 6.añadir un objeto(entidad)
7.añadir una lampara
8. añadir un sonido
9. añadir un texto
10.correr el juego
11. tipo de render(tecnologia que se usa para visualizar las escena)
12.selector de escenas
13.opciones de escena
Pestañas
En el panel izquierdo de maratis hay tres
pestañas para editar opciones sobre los objetos,
de izquierda a derecha la primer tiene opciones
para editar las transformaciones del objeto
seleccionado, es decir la posición, la rotación y
la escala del objeto.
En la segunda pestaña se encuentra opciones
inherentes a cada objeto individualmente como
se la animación que tiene y opciones de las
simulación física del mismo. En la tercera
pestaña se pueden añadir comportamientos que
hacen que un objeto siempre oriente su
dirección a hacia otro objeto o un objeto siga a
otro cundo este se mueve; estos casi siempre se
usan para definir el comportamiento de una
cámara.
Cabe mencionar que el formato de archivo 3D
nativo de maratis es el .mesh y los niveles se
guardan en un archivo .level, también se puede
programar el comportamiento en Lua para crear
un videojuego sencillo dando clik en opciones
de escena y en el panel izquierdo aparecerá la opción “Script” se da clic y se selecciona el archivo
de lua donde hemos programado el comportamiento de los objetos en la escena, para
documentación de la codificación el Lua puede ver la documentación oficial:
http://wiki.maratis3d.org/index.php?title=Lua_scripting
LLEGA C++
Si eres diligente a estas alturas ya habrás averiguado que en maratis se hacen los juego con el editor,
se programa el comportamiento en lua y para tener mas opciones se programan plugins con C++, al
menos esta es la manera que se fomenta en la pagina oficial, pero a mi opinión esta manera no es ni
cómoda ni óptima así que propongo otra manera: Hagamos que C++ sea la herramienta principal y
que el editor de maratis y el código en Lua sea secundario.
Debemos tomarnos una pausa aquí para explicar la diferencia entre el motor de Maratis y el Editor,
primero, el motor de Maratis engloba las rutinas que contienen al motor gráfico, al matemático y al
físico, además trae rutinas para la reproducción de audio y una api, este conjunto de componentes

8. facilita en sobre manera el trabajo de desarrollar un videojuego ya al desarrollador solo le queda el
trabajo de programar los escenarios, la jugabilidad y la IA del juego.
El editor de Maratis es solamente un pequeña aplicacion que haciendo uso de las rutinas
mencionadas anteriormente nos facilita la tarea de ubicar los objetos, luces y cámaras dentro de la
escena y a vincular todo con un código de lua para crear un juego simple y además el editor puede
exportar el ejecutable de un juego final que funciona también con las mismas rutinas.
Volviendo al metodo que propuse anteriormente consiste en programar en C++ usando las rutinas de
motor de Maratis obviando el uso del editor como principal herramienta para el desarrollo, para esto
en vez de usar lo que el programa que descargamos vamos a bajarnos el código fuente de maratis
para trabajar directamente con el.
Para poder bajarnos el código fuente de maratis necesitamos instalar subversion, en ubuntu se
instala con este comando: sudo apt-get install subversion y tambien necesitamos las los archivos de
C++ para trabajar con OpenGl los cual los podemos instalar con: sudo apt-get install freeglut3-dev
y por ultimo ocupamos las herramienta de compilacion de C++ la instalamos con: sudo apt-get
install build-essential una vez que tenemos instalado todo esto nos vamos de nuevo a la pestaña de
descarga en la pagina: http://www.maratis3d.org/?page_id=57 y nos vamos a “Source Code” y
entramos al enlace.
Luego copiamos la linea remarcada y la pegamos en una terminal.
Presionamos enter y en código fuente se descargará automáticamente.

9. Ahora revisamos nuestra carpeta personal, por lo general el codigo fuente se descarga aquí a menos
que lo hayamos configurado para que se haga en otra carpeta. Buscamos la carpeta llamada
“maratis-read-only” esta carpeta contiene el código fuente entero del motor de maratis y del editor.
Podemos echar un vistazo a la carpeta y esto es lo que veremos:
A nosotros nos interesa la carpeta trunk que es donde esta todo el código de maratis y la carpeta
3rdparty contiene código de terceros que maratis necesita para funcionar. El desarrollador de
maratis utilizó una herramienta llamada Scons para compilarlo por lo que ocupamos tener python
2.x instalado en el computador, si eres usuario gnu/linux no tendras problemas con esto.
Para compilar maratis necesitamos entrar a la carpeta trunkdev y vemos un archivo llamado
scons.py, al ejecutar este archivo la compilación de maratis se ejecuta automáticamente.
Para ejecutarlo abrimos una terminal y escribimos cd ~/maratis-read-only/trunk/dev para ubicarnos
en la carpeta donde está el archivo a ejecutar, es muy recomendable cambiar ~ por la dirección
absoluta de la carpeta. Luego ejecutamos el comando python scons.py y en seguida empezará a
compilar el código.
Si el codigo se compila correctamente deberá dar este mensaje al final:
en caso de culminar exitosamente la compilación se va a crear una subcarpeta llamada prod dentro
de la carpeta dev acá se guarda el producto final de la compilación ahora entramos a las carpeta que

10. tenga el nombre de nuestro sistema incluido en el nombre, en mi caso linux2, habrá una carpeta
llamada release dentro y dentro de release eso:
La carpeta MSDK contiene los archivos que integran el motor de maratis: libMCore y libMEngine
La carpeta Maratis contiene además de los archivos mencionados anteriormente los archivos que
integran el editor, aquí tenemos los archivos que descargamos anteriormente.
En la carpeta Examples contiene un ejemplo de uso del motor del maratis con C++ sin usar el
editor, y este ejemplo es de especial importancia para nosotros porque vamos a hacer exactamente
lo mismo que en el ejemplo, si lo ejecutamos vemos esto:
mas tarde nos internaremos en su codigo fuente y explicaré como funciona.
En caso de que usen un So de 64 bits es posible que se haya lanzado este error durante la
compilación:

11. Este error se debe a que algunas de las librerias que estan en la carpeta 3rdparty ya vienen
compilados pero vienen compilados para 32 bits por lo que hay que reemplazarlos por otras de 64
bits, bájatelas acá: https://www.mediafire.com/?efmer587r2yi9u5 y descomprimes el archivo en la
carpeta maratis-read-only para reemplazar las librerías de 32 bits.
CONOCIENDO EL CODIGO FUENTE
Si volvemos a la carpeta dev vamos a ver una serie de carpetas que vemos a continuación:
En todas estas carpetas están distribuidos todos los archivos que componen tanto el motor de
maratis como el editor, para abrir el proyecto con un IDE de C++ nos vamos a la carpeta de Projects
donde vamos a encontrar a maratis como proyectos de IDE para cada plataforma pero la carpeta que
de verdad nos interesa es la carpeta Examples, dentro de la carpeta examples hay subcarpetas
llamadas: CodeBlocks10 que es donde esta el proyecto para el IDE, la carpeta Data que es donde
está los recursos audiovisuales en especial los objetos 3D, y la carpeta ManualUse que es donde
esta el código fuente del proyecto, este proyecto es el que abrimos anteriormente, entraremos a la
carpeta CodeBlocks10 y abriremos el proyecto.
Nos encontramos que el proyecto tiene dos archivos de código: Main.cpp y MyGame.cpp, en el
primero se encuentra en código necesario para arrancar el motor e iniciar una ventana en pantalla,
para entender esta parte es recomendable que te des una vuelta por la documentación:
http://wiki.maratis3d.org/index.php?title=Code_documentation ahora vemos el código de
MyGame.cpp en el cual voy a explicar:
El archivo MyGame.cpp tiene una clase con el mismo nombre que hereda de la clase MGame, la
clase MGame es en si un juego, al heredar una clase de MGame podemos crear un juego completo
dentro de esta clase y correrlo en fácilmente por medio de polimorfismo.
La clase MGame tiene aparte del constructor y destructor dos métodos sobrescritos que se llaman
onBegin() y update().
El método onBegin se ejecuta cuando el juego se inicia, es decir cuando la ventana del juego acaba
de aparecer en pantalla, en el ejemplo que analizamos es donde se cargan los objetos 3D y se le
aplican los comportamientos fiscos.
El método update es el que se ejecuta cada vez que un fotograma es dibujado en pantalla.
A continuación explico el código del método onBegin:
MEngine * engine = MEngine::getInstance();
MSystemContext * system = engine->getSystemContext();

12. Acá se obtiene un puntero a la instancia del motor que actualmente esta corriéndose, puntero engine
apunta a la instancia del motor entero mientras que system apunta a una parte del motor que
denominamos sistema ya que tiene métodos que tienen que ver con el control de ventanas, manejo
de directorios, etc.
La primera obtiene un puntero
hacia el nivel del juego activo llamado level, la desicion if comprueba que el valor del puntero no
sea null, en caso de que el puntero level tenga valor null significa que no se pudo obtener
exitosamente el nivel y Mlog envía un mensaje de error a consola.
Es esta linea se comprueba si el nivel que acabamos de obtener esta vacío, es decir no tiene ninguna
escena, en caso de no tener ninguna vamos a construir una como veremos mas adelante.
En la primera linea se crea un arreglo de caracteres que servirá para guardar direcciones de los
objetos 3D que vamos a cargar posteriormente, la segunda linea obtiene la dirección del directorio
de trabajo, es decir la dirección de la carpeta donde se encuentra nuestro juego.
Recordemos que en nivel esta vacio por lo que le añadimos una nueva escena en la primera linea.
Ahora la escena existe pero carece de los componente característicos de toda escena 3D para
empezar la camara, la añadimos en la segunda linea, en las tres linea restantes le damos
propiedades, para empezar el color de fondo, el método setClearColor recibe como parametro un
objeto tipo MVector el cual básicamente es como un vector en matemáticas y física, los
MLevel * level = engine->getLevel();
if(! level)
{
MLOG(4, "Cannot get level from engine");
return;
}
if(level->getScenesNumber() == 0)
{
char filename[256];
const char * workingDir = system->getWorkingDirectory();
// add scene
MScene * scene = level->addNewScene();
// camera
MOCamera * camera = scene->addNewCamera();
camera->setClearColor(MVector3(0.5f, 0.5f, 0.5f)); // set grey clear color
camera->setPosition(MVector3(0.0f, -80.0f, 20.0f));
camera->setEulerRotation(MVector3(90.0f, 0.0f, 0.0f));

13. componentes del vector representan la cantidad de color rojo verde y azul respectivamente.
Los dos métodos restantes le dan posición lineal y rotacional a la cámara, también reciben como
parámetros vectores, y si bien recordamos que en fisica todo son vectores en el desarrollo de
videojuegos ocurre algo similar.
Es esta sección de código carga el primer objeto 3D en la escena, cabe destacar a en maratis se les
llama entidades a los objetos 3D.
En la primer linea de código se obtiene la dirección absoluta de archivo que queremos cargar en
nuestra escena con el método getGlobalFilename, el primer parámetro es la variable donde
pensamos almacenar la dirección absoluta, es segundo parámetro es el directorio de trabajo que
obtuvimos anteriormente y el ultimo la dirección relativa del objeto dentro del directorio de trabajo.
La segunda linea lee la malla del objeto, se podría ver la malla como la descripción de la forma del
objeto.
En la ultima linea se crea un objeto 3D en la escena a partir de la malla que hemos cargado en
memoria anteriormente.
// add robot entity
getGlobalFilename(filename, workingDir, "meshs/robot.mesh");
MMeshRef * meshRef = level->loadMesh(filename);
MOEntity * robot =scene->addNewEntity(meshRef);
{
// create entities
getGlobalFilename(filename, workingDir, "meshs/box.mesh");
meshRef = level->loadMesh(filename);
MOEntity * box1 = scene->addNewEntity(meshRef);
MOEntity * box2 = scene->addNewEntity(meshRef);
MOEntity * box3 = scene->addNewEntity(meshRef);
// set coords
box1->setPosition(MVector3(70, 65, 0));
box1->setScale(MVector3(4, 4, 0.2f));
box2->setPosition(MVector3(70, 65, 40));
box2->setEulerRotation(MVector3(0, -35, 0));
box3->setPosition(MVector3(75, 65, 70));
// enable physics, MPhysicsProperties create a static box shape by default
MPhysicsProperties * phyProps = box1->createPhysicsProperties();
phyProps = box2->createPhysicsProperties();
phyProps->setMass(1);
phyProps = box3->createPhysicsProperties();
phyProps->setMass(1);
}

14. En las primeras lineas ocurre exactamente lo mismo que la sección anterior, solo cabe destacar que
se crean varios objetos 3D en la escena con la misma malla, esto se puede hacer cuando todos los
objetos en la escena son idénticos.
Lo interesante de esta seccion esta en la linea: MPhysicsProperties * phyProps = box1-
>createPhysicsProperties(); que es donde se crea la simulacion fisica para el objeto box1, phyProps
apunta a las propiedades físicas del objeto, la linea: phyProps->setMass(1); le dice al objeto que su
masa es de 1 kg.
No voy a hablar de del resto del código del método porque es un poco mas de los mismo. Se añade
un texto bajo los mismos principios que los objetos y al final se añade una lampara a la escena y se
posiciona.
Ahora voy a hablar un poco sobre el método update().
Acá se da casi lo mismo que al principio de el método onBegin(), se obtiene una instancia del motor
que esta corriendo actualmente pero en vez de obtener una puntero system se obtiene una de input
que es sirve para controlar la entrada por mouse, teclado y joystick.
La ultima linea llama a la función update() de la clase base, sino llamamos a este método los
fotogramas no se dibujaran en pantalla y solo tendremos una pantalla oscura.
En esta sección obtiene el nivel y escena activa en el juego, los ifs son para interrumpir la ejecución
del método en caso de que se fracase al obtener el nivel o la escena.
MEngine * engine = MEngine::getInstance();
MInputContext * input = engine->getInputContext();
MGame::update();
MLevel * level = engine->getLevel();
if(! level)
{
return;
}
// get current scene
MScene * scene = level->getCurrentScene();
if(! scene)
{
return;
}

15. El método getEntityByIndex(0) obtiene un objeto de la escena mandandole como parametro el
numero de este, dicho numero se asigna en el orden en que fueron creado en la escena empezando
por el cero, también se puede darles una cadena de caracteres como nombre a un objeto.
El metodo addAxisAngleRotation() es un metodo para rotar un objeto dándole el valor del angulo
que queremos que rote dándole primero un vector con valor 1 para los ángulos donde se quiere
realizar dicha rotación.
El método isKeyPressed() devuelve true si se presiona una tecla del teclado especifica dándole
como parámetro una cadena que representa a la tecla, para conocer todos los identificadores visite la
documentación en la wiki.
Los método setIntensity() y getIntensity() son para especificar la intensidad de la luz que emite la
lampara y para conocerla respectivamente.
Hasta acá llegaré con esta breve introducción a Maratis con C++, te dejo los experimentos e
investigación en la documentación a ti, tal vez mas adelante escriba un libro y no una simple
introducción como esta.
Para crear tu propio juego con lo que aprendiste acá puede modificar el codigo de la clase MyGame
y trabajar con los dos metodos que te enseñé, pero si te siente mas experimentado puedes crear un
proyecto nuevo y vincularlo con los scripts de construcción de scons para compilarlo.
MOEntity * entity = scene->getEntityByIndex(0);
if (entity)
entity->addAxisAngleRotation(MVector3(0.0f, 0.0f, 1.0f), 1.0f);
// change light intensity with keyboard
MOLight * light = scene->getLightByIndex(0);
if(light && input->isKeyPressed("UP"))
{
// inputs are also virtual, you can create your hown keys or axis
light->setIntensity(light->getIntensity() + 0.1f);
}
if(light && input->isKeyPressed("DOWN"))
{
light->setIntensity(MAX(0.0f, light->getIntensity() - 0.1f));
}