C++ y Lua para videojuegos

[pchack]

Hola Gente,
he estado ocupado estos dias por eso he tenido poca actividad en el foro,
bueno estos dias investigando un poco sobre motores de juegos 2d, encontre uno llamado "LÖVE"
(http://love2d.org/) y me ha gustado mucho principalmente porque este programa es solo
un ejecutable, a este se le entrega un carpeta que contiene un archivo en lua (main.lua), en dicho
archivo se escribe el codigo del juego que luego se interpreta con el motor.

me parece interesante dicho motor porque creo que facilita la distribucion de juegos, y ademas
porque tiene distintos modulos muy utiles, como poder controlar particulas, fisica, imagenes, en otros.

mi pregunta es ¿como se puede desarrollar un ejecutable en c++ el cual sea capaz de interpretar codigo lua?.

este ejecutable seria algo asi como un interprete de codigo lua que llame funciones c++ (podrian ser de SFML O SDL).

Saludos y espero su colaboracion.

Gracias de Antemano.

[carlostex]

Hola, este es un tutorial de como integrar Lua en C++ usando swig que es un programa que hace el port de C++ a código reconocible por Lua. http://www.swig.org/Doc1.3/Lua.html#Lua_nn7.

Al principio tiene el ejemplo de una aplicación que llama al interprete y sin embargo tiene cargado un módulo que es el código en C++ ya traducido en llamadas a la biblioteca de lua para realizar todo. por lo que si compilas ese ejemplo te va a decir que no se puede linkear esa función. Esto es por que existen dos formas de hacer lo que quieres, una es creando el módulo e incluirlo en un programa que va a ser el que incluya el módulo y el interprete. la otra es hacer como dice en la guia una biblioteca dinámica en los dos casos se tiene que usar swig para hacer el port todos los archivos se incluyen para ser compilados junto con el código que arroja el swig, con esto se crea un biblioteca dinámica que puede ser llamada desde un programa en C++, en este caso no se usa el interprete, pero la misma biblioteca puedes usarla abriendo el interprete de lua y llamando a la biblioteca dinámica, este es un ejemplo de un programa que hice:

Código: Seleccionar todo

#!/usr/bin/lua
require("libtank_war")
g=libtank_war.game();
g:init_video(800,600,32);
--a=libtank_war.audio();
--a:add_chunk("../sounds/disp.wav");
--a:add_chunk("../sounds/disp_mis.wav");
--a:add_audio("../sounds/intro.ogg");
--a:reproducir();

g.scene:set_world("../images/terreno/path");
g.scene:add_sprite("../images/E-P8.854.png",1);
g.scene:add_sprite("../images/anillo.png",1);
g.scene:add_sprite("../images/explode1.png",7);
.
.
.


Si te das cuenta la primera linea esta para que cuando le de doble clic se abra el interprete la función require es la forma en la que se llama a la biblioteca dinámica desde lua, la versión que uso es 5.1, la forma de llamar cambia en la 5.0

pero modificando un poco el código que tiene de ejemplo el tutorial quedando así:

Código: Seleccionar todo

extern "C" {
   #include "lua5.1/lua.h"
   #include "lua5.1/lualib.h"
   #include "lua5.1/lauxlib.h"
}
#include<iostream>
using namespace std;


int main(int argc,char* argv[])
{
   lua_State *L;

if (argc<2)
{
  printf("%s: <filename.lua>\n",argv[0]);
  return 0;
}
L=lua_open();
luaL_openlibs(L);   // load basic libs (eg. print)

if (luaL_loadfile(L,argv[1])==0) // load and run the file
{
    cout<<"Control sedido al interpreter"<<endl;
  lua_pcall(L,0,0,0);
}
else
  printf("Error al cargar %s\n",argv[1]);
lua_close(L);
cout<<"Programa terminado"<<endl;
return 0;
 
   
}


Queda el interprete compilado en un ejecutable, por lo que no tiene que estar presente el ejecutable del interprete pero si sus bibliotecas dinámicas. El código anterior carga un archivo lua y lo ejecuta. podrías pasarle un archivo que contenga:

Código: Seleccionar todo

x=3+2*2
print(x)

y se va a ejecutar.

De esta forma no está cargado ni un módulo es solo el interprete en sí, por lo que en teoría deberías poder cargar cualquier biblioteca dinámica preparada para ser interpretada y esta se debe ejecutar, de hecho hice la prueba y ejecuté el primer código en lua que mostré, y se ejecuto correctamente. Sobre la biblioteca libtank_war se tiene que encontrar en un directorio específico para que el interprete lo tome, o bien indicarle la ruta completa.

En el tutorial vas a encontrar ejemplos y vas a ver todo lo que se puede hacer con Lua y C++, comienza por lo sencillo, has un pequeño programa en c++ de una función hace el port con swig e intenta llamarla con el interprete.
En el tutorial no explica una cosa importante, al hacer el port swig recibe un archivo con terminación .i que es la declaración de las funciones, clases, etc de lo que tiene que portar, se hace asi:

Código: Seleccionar todo

%module libtank_war
%{
#include "otras_declaraciones.h"

%}
%include <typemaps.i>
class top{
       public:
       int x,y;
       int suma(x,y){return x+y;}


};


este archivo únicamente requiere los prototipos pues al compilar se llama a los .cpp aunque se pueden definir en el mismo código las funciones y también funciona.
Luego solo ejecutas: swig -c++ -lua example.i
y obtendrás un archivo para incluir en tu biblioteca dinámica. Al principio del tuto hay una así que sirve de ejemplo para desarrollar lo demás.
Para finalizar, en la página oficial de Lua puedes descargar las fuentes, me parece que hay para win, al igual que swig.
Saludos.

[.teri]

LÖVE es como un intérprete en el que están totalmente integradas las bibliotecas SDL, OpenGL, OpenAL y PHYSFS.

¿como se puede desarrollar un ejecutable en c++ el cual sea capaz de interpretar codigo lua?.

Primero necesitas un estado de lua, vamos una máquina virtual. Luego ejecutas el código desde archivos de texto o desde simple cadenas de texto de forma sencilla con funciones facilitadas por la biblioteca de lua.

este ejecutable seria algo asi como un interprete de codigo lua que llame funciones c++ (podrian ser de SFML O SDL).

Para eso tienes primero que crear funciones en un formato requerido para lua, por ejemplo "LimpiarPantalla" en SFML y sin entrar en detalles:

Código: Seleccionar todo

static int limpiarpantalla(lua_State *vm){
    miventana->Clear();
    return 0;}


Luego lo registras en lua bajo un nombre, sin más complicaciones "LimpiarPantalla", y ya luego lo llamas cómodamente desde lua como LimpiarPantalla()

@carlostex

Personalmente paso de SWIG, para python quizá valga la pena, pero para una cosa tan sencilla como lua ya me hago sin complicaciones mis modulos y mi propios objetos a mano para ser usados en lua. Se arma una clase base abstracta llamada "proxy" para poder usar cómodamente objetos en C++ desde lua. Se crea en lua un puntero a puntero de proxy, almacenas el objeto que hereda la clase proxy ahí, y le asignas una metatabla con funciones escritas en C/C++ para acceder al objeto y listo.

[pchack]

Saludos Gracias por tu respuesta Carlos ha sido de mucha ayuda,
mira ya me resulto este código:

Código: Seleccionar todo

extern "C" {
   #include "lua5.1/lua.h"
   #include "lua5.1/lualib.h"
   #include "lua5.1/lauxlib.h"
}
#include<iostream>
using namespace std;


int main(int argc,char* argv[])
{
   lua_State *L;

if (argc<2)
{
  printf("%s: <filename.lua>\n",argv[0]);
  return 0;
}
L=lua_open();
luaL_openlibs(L);   // load basic libs (eg. print)

if (luaL_loadfile(L,argv[1])==0) // load and run the file
{
    cout<<"Control sedido al interpreter"<<endl;
  lua_pcall(L,0,0,0);
}
else
  printf("Error al cargar %s\n",argv[1]);
lua_close(L);
cout<<"Programa terminado"<<endl;
return 0;

   
}


ahora he estado intentanto crear un modulo he incorporarlo al programa cpp pero no me resulta,
te explico:
cree un archivo "example.i" con lo siguiente

Código: Seleccionar todo

%module example
%{
#include "example.h"
%}
void imprimir();



example.h puse esto:

Código: Seleccionar todo

#ifndef EXAMPLE_H
#define EXAMPLE_H

void imprimir();

#endif



example.cpp puse esto:

Código: Seleccionar todo

#include <iostream>

using namespace std;

void imprimir(){

cout << "Funciono Modulo" << endl;

}


y en el código donde esta main

Código: Seleccionar todo

extern "C" {
   #include "lua5.1/lua.h"
   #include "lua5.1/lualib.h"
   #include "lua5.1/lauxlib.h"
}

#include<iostream>


using namespace std;

extern int luaopen_example(lua_State* L); // declare the wrapped module


int main(int argc,char* argv[])
{
   lua_State *L;

if (argc<2)
{
  printf("%s: <main.lua>\n",argv[0]);
  return 0;
}
L=lua_open();
luaL_openlibs(L);   // load basic libs (eg. print)
luaopen_example(L);   // load the wrappered module

if (luaL_loadfile(L,argv[1])==0) // load and run the file
{
    cout<<"Control sedido al interpreter"<<endl;
  lua_pcall(L,0,0,0);
}
else
  printf("Error al cargar %s\n",argv[1]);
lua_close(L);
cout<<"Programa terminado"<<endl;
return 0;

   
}


el problema es que no reconoce la función
extern int luaopen_example(lua_State* L);
y no se como se traen el modulo example.h para que lo reconosca lua.

PD: el comando g++ que estoy usando es
g++ "codigo.cpp" "example_wrap.cxx" "example.cpp" -o "codigo" -llua5.1

seria esa mi pregunta y muchas gracias por la ayuda.

Saludos

[carlostex]

Si, lo que sucede es que la definición de esa función es la que creó swig, tienes que incluir es archivo *.cxx en el main, y prueba si funciona, con esto debería.

[pchack]

Genial ya logre compilarlo, ahora tengo un problema que no sé porque ocurre.

muestro los archivos para que vean:

// main.cpp

Código: Seleccionar todo

extern "C" {
   #include "lua5.1/lua.h"
   #include "lua5.1/lualib.h"
   #include "lua5.1/lauxlib.h"
}

#include "example_wrap.cxx"

#include<iostream>




using namespace std;

extern int luaopen_example(lua_State* L); // declare the wrapped module


int main(int argc,char* argv[])
{
   lua_State *L;

if (argc<2)
{
  printf("%s: <main.lua>\n",argv[0]);
  return 0;
}
L=lua_open();
luaL_openlibs(L);   // load basic libs (eg. print)
luaopen_example(L);   // load the wrappered module

if (luaL_loadfile(L,argv[1])==0) // load and run the file
{
   cout<<"Control sedido al interpreter"<<endl;
   lua_pcall(L,0,0,0);
}
else
  printf("Error al cargar %s\n",argv[1]);
lua_close(L);
cout<<"Programa terminado"<<endl;
return 0;

   
}



// example.i

Código: Seleccionar todo

#ifdef SWIG
%module example
%{
#include "example.h"
%}
#endif



//example.h

Código: Seleccionar todo

#ifndef EXAMPLE_H
#define EXAMPLE_H



class motor{
public:
   void iniciar();

};

#endif


// example.cpp

Código: Seleccionar todo

#include <iostream>
#include "example.h"

using namespace std;


void motor::iniciar(){
    cout << "motor: Iniciando" << endl;
}


// main.lua (codigo a interpretar)

Código: Seleccionar todo

// tambien he probado con
// require("example")
// y no interpreta
m=example.motor();

m:iniciar();



ejecuto el comando: main main.lua
output:
Control sedido al interpreter
Programa terminado



el problema es que al llamar a m:iniciar();
no ejecuta nada no se porque esto ocurre.

bueno hasta ahora agradezco su ayuda, me han aclarado bastantes cosas,
así que gracias y espero que me puedan ayudar nuevamente en esto.

Saludos

[carlostex]

Asi como tienes escrito el .lua no va a funcionar, por que tienes que incluir la biblioteca dinámica, el require es para la versión 5.1, si tienes esa y no te funcionó muestra la linea que usas para compilar. El código en lua es correcto y asi como declaraste el módulo debe tener el mismo nombre la biblioteca dinámica, seria example.so
y nada, cualquier duda estamos para eso.

[.teri]

Personalmente para lo que quieres hacer veo mejor que integres tu motor con lua, como hace LÖVE, y no construyas un módulo basado en tu motor para ser usado desde lua.

[pchack]

Saludos, el comando de compilacion de main.cpp que use:
g++ "%f" "example.cpp" -o "%e" -llua5.1

tengo una pregunta, ¿como crear esa libreria example.so?.

Personalmente para lo que quieres hacer veo mejor que integres tu motor con lua, como hace LÖVE, y no construyas un módulo basado en tu motor para ser usado desde lua.

hola .teri como se haria eso, integrar el motor con lua
si me orientaras seria genial.


Saludos y gracias por su ayuda.

[.teri]

Para integrar tu motor con lua tienes que hacer una aplicación, con su función main y todo, y enlazarlo con la biblioteca de lua, también si tienes tu motor como una biblioteca dinámica o estática pues igualmente lo enlazas. Haces lo mismo: creas un estado de lua al principio y lo cierras al final. En un archivo o archivos aparte creas funciones de lua escritas en C que se van a encargar de comunicarse con tu motor y luego registras esas funciones en el estado de lua que hiciste.

Puedes hacer más cosas con lua. Por ejemplo puedes hacer un archivo de configuración situado al mismo nivel que el ejecutable que puede tener por ejemplo la anchura o la altura de la ventana a crear y cambiar a tu antojo la creación de una ventana sin tener que recompilar.

[carlostex]

Puedes hacer más cosas con lua. Por ejemplo puedes hacer un archivo de configuración situado al mismo nivel que el ejecutable que puede tener por ejemplo la anchura o la altura de la ventana a crear y cambiar a tu antojo la creación de una ventana sin tener que recompilar.

En el archivo lua que postee asi esta, al llamar a la función que inicializa la ventana le paso los parámetros que quiero y no tengo que recompilar, ya es cuestión de usar archivos aparte de lua para definir los parámetros del juego y cargarlos en un archivo principal.
En realidad no veo mucha diferencia con lo que dices a lo que pchack quiere hacer.

Pensé que te referías a instanciar objetos en lua pero todo se ejecuta en C, de esta forma no hay que compilar de nuevo para cambiar los atributos que se le dan a las clases, pero esto ya es un poco mas complicado, pues los archivos de intercambio son mas especiales y el programador es el que los tiene que crear.

Siguiendo con lo de pchack, me di cuenta con tu pregunta que te he llevado a un error. No es necesario incluir en main.cpp el archivo de tu juego, ese programa únicamente contiene al interprete y lo que hace es abrir un archivo para interpretar:

Código: Seleccionar todo

extern "C" {
   #include "lua5.1/lua.h"
   #include "lua5.1/lualib.h"
   #include "lua5.1/lauxlib.h"
}


#include<iostream>

using namespace std;

int main(int argc,char* argv[])
{
   lua_State *L;

if (argc<2)
{
  printf("%s: <main.lua>\n",argv[0]);
  return 0;
}
L=lua_open();
luaL_openlibs(L);   // load basic libs (eg. print)

if (luaL_loadfile(L,argv[1])==0) // load and run the file
{
   cout<<"Control sedido al interpreter"<<endl;
   lua_pcall(L,0,0,0);
}
else
  printf("Error al cargar %s\n",argv[1]);
lua_close(L);
cout<<"Programa terminado"<<endl;
return 0;

   
}

Así debería quedar el archivo, por otro lado tienes a example.cpp example.h y example_wrap.cxx estos son lo que vas a compilar en una biblioteca dinámica.

g++ -I/usr/include/lua5.1 -c example_wrap.cxx -o example_wrap.o
g++ -c example.cpp -o example.o
g++ -shared -I/usr/include/lua5.1 -L/usr/lib/lua example_wrap.o example.o -o example.so

por cierto que IDE usas, supongo que lo usas por la linea de compilación que pusiste y se me hace como al geany, no me quedó claro en que SO estás desarrollando, pero si usas Linux es mejor que uses un programa que te haga la compilación de todos los archivos, por que cuando tu código crezca vas a tener que dividirlo en una jerarquía de archivos y se puede convertir un dolor de cabeza compilarlos

[.teri]

En el archivo lua que postee asi esta, al llamar a la función que inicializa la ventana le paso los parámetros que quiero y no tengo que recompilar, ya es cuestión de usar archivos aparte de lua para definir los parámetros del juego y cargarlos en un archivo principal.
En realidad no veo mucha diferencia con lo que dices a lo que pchack quiere hacer.

Cuestión de organización. ¿Para qué crear y mantener un módulo? La misión del script es decirle al motor qué es lo que tiene que hacer, no el cómo.

Personalmente veo mejor y más sencillo un archivo en lua, atendiendo al ejemplo de crear una ventana, que contenga estas líneas

Código: Seleccionar todo

Ancho = 640
Alto = 480


que uno que contenga esta línea

Código: Seleccionar todo

ventana = m:crearventana(640, 480)


El primer caso simplemente se lee el archivo, se mira si están definidas en Ancho y Alto en lua, se almacenan en dos enteros y se crean la ventana a partir de esos dos enteros, y todo esto se puede hacer desde la función principal sin muchos problemas y sin necesidad de crear un módulo, solamente el ejecutable.
El segundo caso, necesitas crear nada más que una función que se comunica con otra función encarga de crear una ventana y registrarlo en lua todo desde un módulo. Ok, SWIG hace eso por tí, pero para mi gusto veo el problema del mantenimiento y la organización. Más que nada a mi parecer uno no tiene control de lo que estas haciendo. Además, ¿qué necesidad tiene uno de crear varias "instancias" de motor cuando solamente tiene sentido que haya un solo motor? No contando además se que puede iniciar el motor sin necesidad de módulo desde un iniciar() en vez de m:iniciar(), o mejor aún, de ninguna forma.

Pensé que te referías a instanciar objetos en lua pero todo se ejecuta en C, de esta forma no hay que compilar de nuevo para cambiar los atributos que se le dan a las clases, pero esto ya es un poco mas complicado, pues los archivos de intercambio son mas especiales y el programador es el que los tiene que crear.

No sé si te refieres a lo que viene a continuación pero mira, me contruí un proxy de esta forma. La clase base lo uso de como "base" para aquellos objetos en C++ que me gustaría comunicarme desde lua. Se crea primero con lua_newuserdata el luaproxy y se le asigna el objeto. En un ejemplo asignas __newindex en una metatabla que será usada por el proxy. Y sabiendo que el primer indice es tu objeto (proxy), el 2º indice una clave (string) y el 3er indice un valor cualquiera puedes sobrecargar el método NewIndex (proxy.key = data) de tu objeto como te plaza y usarlo desde lua y tratarlo desde el método.

Código: Seleccionar todo


class base{
    public:
        virtual void NewIndex(lua_State *) = 0;
        virtual void Index(lua_State *) = 0;
};

struct luaproxy{
    base *object;
};

static int __newindex(lua_State *vm){
    //proxy, key, data
    luaproxy *theproxy = lua_touserdata(vm, 1);
    theproxy->object->NewIndex(vm);
    return 0;
}

static int __index(lua_State *vm){
    //proxy, key
    luaproxy *theproxy = lua_touserdata(vm, 1);
    theproxy->object->Index(vm);
    return 1;
}



Algo más avanzado, con esto y una función lua escrita en C/C++ puedes aprovechar el recolector de basura de lua para crear objetos de c++ desde lua y sobrecargando __gc puedes borrar la instancia de la clase cuando el recolector de basura lo vaya a borrar.

Otra cosa, puedes sustituir esto

Código: Seleccionar todo

extern "C" {
   #include "lua5.1/lua.h"
   #include "lua5.1/lualib.h"
   #include "lua5.1/lauxlib.h"
}


por esto

Código: Seleccionar todo

#include <lua5.1/lua.hpp>


[carlostex]

SWIG hace eso por tí, pero para mi gusto veo el problema del mantenimiento y la organización. Más que nada a mi parecer uno no tiene control de lo que estas haciendo. Además, ¿qué necesidad tiene uno de crear varias "instancias" de motor cuando solamente tiene sentido que haya un solo motor? No contando además se que puede iniciar el motor sin necesidad de módulo desde un iniciar() en vez de m:iniciar(), o mejor aún, de ninguna forma.

Hacer las declaraciones de lo que quieres exportar a lua es como hacer un makefile de un proyecto de 100 fuentes a mano, para eso existe swig, realiza las llamadas a la biblioteca de lua para poder ser llamadas desde el interprete.
Lo que dices de llamar a funciones como iniciar(), ya sería mas propio del lenguaje. Por ejemplo pilas usa pysfml la cual no está escrita en python (que yo sepa) de cualquier forma muchas funciones en python son llamadas de bibliotecas dinámicas escritas en C/C++ es lo mismo que se hace con lua, solo que tu escribes esos módulos.
Que es mejor si iniciar() o m:iniciar(), es subjetivo, sobretodo si es un motor para un juego específico, aprendi esto de lua por que también escribí un motor la forma en la que se hacen las llamadas desde lua al motor asustaría a muchos, por que es ineficiente. Me gusta mas la forma es que lo hace pilas, que es trabajar con las instancias de objetos en el motor, lo cual se puede hacer con lua. Como dices es cuestión de organización y la forma de estructurar el interprete, en este caso y en el mio, usamos lua como un guion que indica como se desarrolla el juego, lo bueno de ser interpretado es que se puede cambiar el guión y hacer un juego diferente, ese es el principal principio que seguí, lo demás son cosas técnicas.
Por cierto, si tienes ejemplos de lo que hayas hecho con lua pasalos no?

[.teri]

Hacer las declaraciones de lo que quieres exportar a lua es como hacer un makefile de un proyecto de 100 fuentes a mano, para eso existe swig, realiza las llamadas a la biblioteca de lua para poder ser llamadas desde el interprete.

Depende qué estas exportando exactamente o si es lo más adecuado o no. Lua también lo uso para escribir código de alto nivel, no funciones o métodos individualizados, aparte de usarlo como lenguaje de descripción. Personalmente veo que si uno llega a decir eso (lo de escribió), entonces deberías pensar seriamente el diseño o la solución porque seguramente estas haciendo algo mal.

Por cierto, si tienes ejemplos de lo que hayas hecho con lua pasalos no?

Bueno, jamás pensé que llegaría a escribir esto, y no sé si es lo más adecuado como para ejemplo. Estuve haciendo un proyecto, funcional, pero no terminado de algo parecido a LÖVE pero de muy alto nivel, gran ejemplo de lo que estaba haciendo, y en el que tan solo tienes que escribir qué es lo que vas a hacer.

http://code.google.com/p/bangameengine/

Por ejemplo, si quieres escribir "hola mundo" por pantalla, nada más desde un archivo lua tienes que escribir

Código: Seleccionar todo

bange.SetBgColor(50, 50, 50)

scene = bange.NewScene(1)
view = bange.NewView()

view.scene = scene

scene:SetLayer(1, LayerObject)
string = scene[1]:AddSimpleString("Hello world!")

bange.Run = {views = {view}}



No, lo de "bange" no es un objeto, es una tabla donde he almacenado todas las funciones, que son pocas y las justas, para comunicarse con el motor, algo así como un namespace de C++. Si ves las distintas clases como scene o layer, verás como se propaga los métodos NewIndex o Index por las clases padres o hermanas. Si te descargas el proyecto desde mercurial (que es de la única forma), verás el ejemplo en un archivo 7z, que puedes llamar escribiendo "bange helloworld.7z". Dentro del paquete verás config.lua donde está la configuración de la ventana, y run.lua que es el código escrito aquí. Mira sobre todo el módulo base del proyecto, porque ahí es donde está todo el meollo.