Conforme pasó el tiempo, los juegos dejaron de ser esos pequeños programas triviales para convertirse, poco a poco, en el colmo de la complejidad computacional.
Un juego abarca casi todos los ámbitos informáticos y los lleva hasta los límites del tiempo real contemporáneo. Gráficos, Inteligencia Artificial, Redes, Sonido, Sintetizadores, Sistemas de Archivos Virtuales, Recursos, Arquitecturas, Generación Procedural, Ingeniosos Patrones de Diseño...
A mediados de los 90 la complejidad había crecido hasta el límite en el que poderosos motores quedaban desaprovechados por las limitaciones de las configuraciones que admitían. A pesar de ser bastante dinámicos y abiertos (para esa época) sólo se permitían configuraciones sencillas que fueran rápidas de procesar. Cualquier cambio mayor requería compilar el juego entero, algo que entonces suponía varios días y dificultaba extraordinariamente la creación de parches, por lo que las nuevas modificaciones eran difíciles de distribuir.
Así surgió la necesidad de incorporar motores de script a los videojuegos, haciendo que parte del código del juego fuese soportado en scripts de texto plano que se podían cambiar en cualquier momento sin necesidad de compilar. Muchos juegos tuvieron su propio lenguaje de script, a menudo muy limitado, pero que permitía con mayor o menor suerte lograr un entorno dinámico y configurable. Estos pioneros siguieron la evolución natural que sus motores pedían a gritos.
Por fortuna, en 1993 nació LUA, un lenguaje "semi"-interpretado que destacaba por su velocidad y su capacidad de extensión. No era puramente interpretado puesto que los scrips se podían compilar (al vuelo o no) a bytecode, usando una máquina virtual para su ejecución. Su flexibilidad, su licencia, y su genial integración con C hicieron que desde entonces miles de juegos lo adoptasen en masa.
LUA fue usado en toda la saga de Baldur's Gate, por ejemplo, y también es la base del motor de interfaz de World Of Warcraft. Heroes V, Crysis, Mods del Half-Life 2... etc, está avalado por muchos de los más grandes.
(***)
En mi opinión, la pega más importante de LUA es su integración con C++ (que no con C). Hacer los "bindings" entre clases LUA/C++ es un coñazo a menudo insoportable para la gente que, como yo, no quiere perder el tiempo escribiendo lo mismo 2 veces. Sin embargo, hace algunos años, cuando tenía en mente el desarrollo del motor para el juego de rol de-fi-ni-ti-vo, encontré una ingeniosa solución a este engorroso tema; y de eso voy a hablar hoy.
La solución implica renunciar al orientado a objetos en LUA, pero podremos usar las clases de C++ mediante funciones al estilo C en LUA. Por ejemplo, si tenemos una clase "Personaje" en C++, que tiene un método "Envenenar()", en LUA podremos hacer algo cómo:
Envenenar(personaje);Es decir, renunciamos a la sintaxis de OO, a la herencia y a la encapsulación, pero podremos trabajar con todos los métodos originales de clases escritas en C++. Dado que los scrips en los juegos suelen ser muchos pequeños paquetes (recalco lo de pequeños), es bastante cómodo trabajar así y crear nuestros propios comandos
KISS.
(***)
La idea:La idea es que todas los objetos C++ tengan un identificador númerico único. En C++ crearemos los comandos que recibirán un número que será el ID del objeto con el que trabajaremos (además de otros argumentos necesarios para el comando en cuestión).
Por ejemplo, veamos el siguiente código en LUA:
personaje1=CrearPersonaje("LaNsHoR",100);El método CrearPersonaje("LaNsHoR",100) presuntamente crea un objeto Personaje de C++ llamado "LaNsHoR" y que tiene 100 puntos de vida. La línea anterior da a entender que un objeto Personaje análogo en LUA se ha guardado en la variable "personaje1",
pero realmente sólo se ha guardado un entero: el identificador único del objeto real que sólo existe en C++.
Es decir, en el motor en C++ existe un personaje llamado LaNshoR con 100 de vida que se ha creado con el comando "CrearPersonaje", y que además tiene, por ejemplo, un identificador numérico único (algo así como el DNI) y exclusivo que podría ser, por ejemplo "352".
El comando "CrearPersonaje" devuelve el ID del objeto que acaba de crear, así que la variable "personaje1" en LUA sólo contiene el número "352".
Esa es la idea, ahora escribiremos en C++ otro comando, por ejemplo "Envenenar()", que ha de recibir el personaje al cual queremos envenenar. Como desde LUA sólo tenemos los IDs de los objetos, realmente la función Envenenar recibirá un ID, y el motor, ya desde C++, buscará el objeto con ese ID y lo envenenará.
Obviamente, no vamos a ir preguntando uno por uno a todos los objetos que tengamos cual es su "DNI" y comparándolo para ver si ese es el objeto que buscamos. En un juego pueden haber 1000 monstruos, 100000 objetos, 200 casas, 50000 muebles... y buscar uno por uno sería bastante lento (y estúpido). Así que para evitar esto diseñamos una nueva estructura/patrón de diseño que yo llamo "el mega vector".
(***)
Para que todos los objetos tengan un ID único crearemos una clase "Identidad" de la que todas las demás heredarán. Esta clase simplemente asigna un atributo ID a cada objeto y va incrementando un contador estático para el siguiente:
#ifndef __identidad__
#define __identidad__
class Identidad
{
private:
static unsigned int _contador;
unsigned int _id;
public:
Identidad();
~Identidad();
unsigned int getID();
};
unsigned int Identidad::_contador=0;
Identidad::Identidad()
{
_id=_contador;
_contador++;
}
Identidad::~Identidad() {}
unsigned int Identidad::getID()
{
return _id;
}
#endif // __identidad__
Con esto hemos conseguido 2 cosas: la primera, todos los objetos tendrán una ID automática sin que tengamos que hacer nada, y la segunda, todos los objetos tendrán una interfaz común como hijos de Identidad, de esta forma podremos aprovechar el polimorfismo para crear la siguiente clase clave: el megavector.
El megavector es un array de punteros a Identidad que contendrá todos los objetos, cada objeto estará en la posición de memoria del array que indique su ID, de esta forma podemos acceder a él directamente sin tener que buscarlo; sólo con un salto a memoria.
El nombre de "megavector" viene porque tendremos que reservar suficiente memoria como para contener todos los posibles objetos que puedan haber simultáneamente en la partida, si usamos por ejemplo medio millón de posiciones necesitaríamos unos 2 megas de ram (32*500000/(8*1024*1024)) sólo en punteros (el doble en sistemas de 64bits), lo cual, no es mucho si tenemos en cuenta la velocidad de acceso que ganamos, y la simplicidad de "hablar" con C++ desde LUA.
Por supuesto podemos hacer dinamismos para ampliar el vector si nos quedamos sin memoria, pero en este ejemplo simple no voy a tratar de hacer eso. Además, otro aspecto importante es la fragmentación: si estamos creando y destruyendo objetos de forma continua iremos avanzando en el contador del megavector dejando atrás casillas vacías. Para solucionar esto simplemente tendremos que tener otro vector de enteros del mismo tamaño en el que iremos guardando las posiciones libres, y con un par de marcadores controlaremos la asignación de IDs.
Un megavector básico y simple, a modo de ejemplo, que no controla la fragmentación ni es ampliable sería el siguiente:
#ifndef __megavector__
#define __megavector__
#include "identidad.h"
#include
class MegaVector
{
private:
int _ocupados;
int _maximo;
Identidad** _vector;
MegaVector(int maximo=500);
static MegaVector* _instancia;
public:
~MegaVector();
Identidad* getElemento(int);
void Insertar(Identidad*);
static MegaVector* getInstancia();
};
MegaVector* MegaVector::_instancia=0x0;
MegaVector::MegaVector(int maximo)
{
_maximo=maximo;
_ocupados=0;
_vector=new Identidad*[_maximo];
for(int x=0;x<_maximo;x++)
_vector[x]=0x0;
}
MegaVector::~MegaVector()
{
for(int x=0;x<_ocupados;x++)
{
if(_vector[x]!=0x0)
delete _vector[x];
_vector[x]=0x0;
}
delete[] _vector;
_vector=0x0;
_instancia=0x0;
}
Identidad* MegaVector::getElemento(int x)
{
if(x>=_ocupados || x<0)
{
std::cerr<<"Error: No puedo acceder a "<endl;
return 0x0;
}
return _vector[x];
}
void MegaVector::Insertar(Identidad* elemento)
{
if(_ocupados>=_maximo)
{
std::cerr<<"Error: No caben más elementos"<endl;
return;
}
_vector[_ocupados]=elemento;
_ocupados++;
}
MegaVector* MegaVector::getInstancia()
{
if(!_instancia)
_instancia=new MegaVector();
return _instancia;
}
#endif // __megavector__
Perfecto, ahora hagamos un juego de ejemplo.
En muchos juegos cosas como los hechizos, o el propio combate esta 100% programado y controlado desde script. A modo de ejemplo voy a crear una clase "Personaje" y una clase "Arma" en C++ y luego escribiré una función en LUA para el combate; haré que los personajes luchen entre ellos con distintas armas en plan duelo, cada arma tendrá hará una cantidad determinada daño y todos los personajes y todas las armas las crearemos dinámicamente desde LUA.
Por supuesto como en todo juego que se precie, el azar debe jugar un papel importante, así que el daño de las armas estará definido por una tirada de un dado de X caras (sí ya sé, en la vida real no vamos a encontrar dados de, por ejemplo, 5 caras, pero en nuestro juego podremos tenerlos si queremos).
Creamos la clase Dado:
#ifndef __dado__
#define __dado__
#include
#include
#include "identidad.h"
#include "megavector.h"
class Dado:public Identidad
{
private:
int _caras;
public:
Dado(int caras=6);
~Dado();
int getTirada();
};
Dado::Dado(int caras)
{
_caras=caras;
MegaVector::getInstancia()->Insertar(this);
}
Dado::~Dado() {}
int Dado::getTirada()
{
return (rand()%_caras)+1;
}
#endif // __dado__
Fijaos en que la clase Dado, hereda de entidad. En el constructor de Dado hago que todos los dados creados "se registren" a si mismos en el megavector, no obstante hubiera sido más correcto hacer esta operación en el constructor de Identidad (así no tendríamos que hacerlo en todos los hijos de Identidad), pero no quería poneros nada del megavector hasta explicarlo, así que por esta vez... lo haremos así.
Ahora crearemos la clase Arma:
#ifndef __arma__
#define __arma__
#include "identidad.h"
#include "megavector.h"
#include "dado.h"
#include
using namespace std;
class Arma:public Identidad
{
private:
string _nombre;
Dado* _dado;
public:
Arma(string,Dado* dado=0x0);
~Arma();
string getNombre();
int Usar();
};
Arma::Arma(string nombre,Dado* dado)
{
_nombre=nombre;
if(!dado)
dado=new Dado(6);
_dado=dado;
MegaVector::getInstancia()->Insertar(this);
}
Arma::~Arma() {}
string Arma::getNombre()
{
return _nombre;
}
int Arma::Usar()
{
return _dado->getTirada();
}
#endif // __arma__
Como podemos ver en el constructor, para crear un arma necesitamos 2 cosas: un nombre, por ejemplo "Espada Larga", y un dado para hacer las tiradas. Un arma a la que le asignemos un dado de 10 caras podrá hacer de 1 a 10 puntos de daño, etc. El método "Usar" lanza el dado del arma y nos devuelve el resultado.
Y por último, creamos la clase Personaje:
#ifndef __personaje__
#define __personaje__
#include
#include "identidad.h"
#include "megavector.h"
#include "arma.h"
using namespace std;
class Personaje:public Identidad
{
private:
string _nombre;
Arma* _arma;
int _vida;
public:
Personaje(string,int vida=100);
~Personaje();
void Equipar(int);
int addVida(int);
string getNombre();
Arma* getArma();
};
Personaje::Personaje(string nombre,int vida)
{
_nombre=nombre;
_arma=0x0;
_vida=vida;
MegaVector::getInstancia()->Insertar(this);
}
Personaje::~Personaje() {}
void Personaje::Equipar(int x)
{
_arma=(Arma*)MegaVector::getInstancia()->getElemento(x);
}
int Personaje::addVida(int x)
{
_vida+=x;
return _vida;
}
string Personaje::getNombre()
{
return _nombre;
}
Arma* Personaje::getArma()
{
return _arma;
}
#endif // __personaje__
La explicación de la clase personaje es simple. Para crear un personaje debemos indicar un nombre y una cantidad de vida inicial. Después tendremos varios métodos, como "Equipar": al que le pasamos un ID de un arma para que, metafóricamente, el personaje la tome y la use para atacar a sus enemigos.
Otro método interesante es "addVida", que recive una cantidad de vida para añadir (o quitar si la cantidad es negativa) y se la resta al personaje, además devuelve la vida final tras hacer la operación. De esta forma, si queremos consultar la vida del personaje podemos hacer "addVida(0)".
Y por fin tenemos todas las clases de nuestro juego! Ahora hagamos los comandos que queremos que estén disponibles desde LUA, los he juntado todos de forma "guarra" en el main para que se vea más claro.
#include
#include
#include
#include "identidad.h"
#include "megavector.h"
#include "personaje.h"
#include "arma.h"
extern "C"
{
#include "lua/lua.h"
#include "lua/lualib.h"
#include "lua/lauxlib.h"
}
using namespace std;
//Comandos LUA
int CrearDado(lua_State *L)
{
Dado* dado=new Dado(lua_tointeger(L,1));
lua_pushnumber(L,dado->getID()); //Devuelve el ID del dado
return 1; //Devuelve el número de valores devueltos
}
int CrearArma(lua_State *L)
{
Dado* dado=(Dado*) MegaVector::getInstancia()->getElemento(lua_tointeger(L,2));
Arma* arma=new Arma(lua_tostring(L,1),dado);
lua_pushnumber(L,arma->getID()); //Devuelve el ID del arma creada
return 1; //Devuelve el número de valores devueltos
}
int CrearPersonaje(lua_State *L)
{
Personaje* personaje=new Personaje(lua_tostring(L,1),lua_tointeger(L,2));
lua_pushnumber(L,personaje->getID()); //Devuelve el ID del personaje creado
return 1; //Devuelve el número de valores devueltos
}
int Equipar(lua_State *L)
{
Personaje* personaje=(Personaje*)MegaVector::getInstancia()->getElemento(lua_tointeger(L,1));
personaje->Equipar(lua_tointeger(L,2));
return 0; //Devuelve el número de valores devueltos
}
int Vida(lua_State *L)
{
Personaje* personaje=(Personaje*)MegaVector::getInstancia()->getElemento(lua_tointeger(L,1));
int vida=lua_tointeger(L,2);
lua_pushnumber(L,personaje->addVida(vida));
return 1; //Devuelve el número de valores devueltos
}
int Tirada(lua_State *L)
{
Dado* dado=(Dado*)MegaVector::getInstancia()->getElemento(lua_tointeger(L,1));
lua_pushnumber(L,dado->getTirada());
return 1; //Devuelve el número de valores devueltos
}
int UsarArma(lua_State *L)
{
Arma* arma=(Arma*)MegaVector::getInstancia()->getElemento(lua_tointeger(L,1));
lua_pushnumber(L,arma->Usar());
return 1; //Devuelve el número de valores devueltos
}
int getArma(lua_State *L)
{
Personaje* personaje=(Personaje*)MegaVector::getInstancia()->getElemento(lua_tointeger(L,1));
Arma* arma=personaje->getArma();
lua_pushnumber(L,arma->getID());
return 1; //Devuelve el número de valores devueltos
}
int getNombre(lua_State *L)
{
Personaje* personaje=(Personaje*)MegaVector::getInstancia()->getElemento(lua_tointeger(L,1));
string nombre=personaje->getNombre();
lua_pushstring(L,nombre.c_str());
return 1; //Devuelve el número de valores devueltos
}
//Main
int main(int argc, char **argv)
{
srand(time(0x0));
const char file[]="script.txt";
lua_State *L=lua_open();
luaL_openlibs(L);
lua_register(L,"CrearDado",CrearDado);
lua_register(L,"CrearArma",CrearArma);
lua_register(L,"CrearPersonaje",CrearPersonaje);
lua_register(L,"Equipar",Equipar);
lua_register(L,"Vida",Vida);
lua_register(L,"Tirada",Tirada);
lua_register(L,"UsarArma",UsarArma);
lua_register(L,"Arma",getArma);
lua_register(L,"Nombre",getNombre);
int s=luaL_loadfile(L,file);
if(s==0)
{
//Ejecución del archivo
s = lua_pcall(L, 0, LUA_MULTRET, 0);
}
lua_close(L);
cout<
"Pulsa ENTER para salir"< cin.get();
return 0;
}
Este programa, ejecutará el archivo "script.txt" con código LUA, desde el que tendremos disponibles lo siguientes comandos:
- CrearDado(x): Donde x es el número de caras.
- CrearArma(nombre,dado): Donde nombre es el nombre del arma, y dado el dado que se usará para calcular el daño.
- CrearPersonaje(nombre,vida): Donde nombre es el nombre del personaje y vida la cantidad de vida inicial.
- Equipar(personaje,arma): Equipar al personaje con el arma indicada.
- Vida(personaje,x): Añade una cantidad X de vida al personaje, y devuelve la vida restante.
- UsarArma(personaje): Hace que el personaje use el arma y devuelve cuanto daño a quitado en esa tirada.
- Arma(personaje): Devuelve el arma del personaje.
- Nombre(personaje): Devuelve el nombre del personaje.
Una vez compilado tendremos nuestro .exe que buscará un archivo de texto "script.txt" y lo ejecutará. En ese archivo que podremos modificar siempre que queramos sin tener que volver a generar el binario ejecutable, crearemos una función de combate con algunos personajes y sus armas, ¡todo usando las clases de C++ desde LUA! ^^.
Este es el archivo script.txt que he escrito con el combate.
El combate funciona de la siguiente manera: por turnos, los personajes usan sus armas para atacarse alternativamente, el primero que llega a 0 puntos de vida (o menos) muere y pierde. Además antes de atacar, cada personaje tira un dado de 20, si saca 20 hace un golpe crítico y el personaje hace el doble de daño, si saca 1 hace un fallo crítico y ese turno no hace nada de daño, y si saca cualquier otra cosa hace el daño normal del arma.
En el archivo creo varios personajes y varias armas para que podáis cambiar el código con cuidado y hacer pruebas. Si lo ejecuta tal y como está... este es el resultado:
Por supuesto el resultado varía en cada ejecución. Podéis editar con cuidado los personajes, las armas, la cantidad de vida, etc del .txt y probar vosotros mismos.
Aquí tenéis el ejecutable con el script.
NOTA: Este programa básico no comprueba errores en la sintaxis o en la ejecución de LUA ni nada parecido. Si editáis algo mal en el archivo de texto el programa no funcionará :P (no uséis acentos, eñes, etc, sólo caracteres de la "a" a la "z" y de "0" a "9"; espacios, guiones bajos, puntos, etc también están permitidos).
PD: He de decir a favor de Gex, que quien ataca primero tiene ventaja ;)
Archivado en: C , LUA, Spanish.
Doncella
Caballero
