Hace tiempo atrás me topé con una maravillosa biblioteca se llama luabind que permite por arte de magia integrar Lua a C++, pero no pude integrarla ya que mi tiempo y mis ganas de aprender como funcionaba eran pocas. Por lo que lei necesitaba compilarse de una manera especial con bjam y Boost Build V2, asi que preferí hacer mi propia implementación pero no desde 0, si no modifiqué un ejemplo encontrado en la wiki de Lua Cpp Binding With Lunar. Con excelentes resultados en esa ocasión.

Ahora le agregué lo que hice en el articulo pasado y obtuve esto.

 print(entero);
 print(string);
 test = Test();
 test.a = 1;
 test.b = 2;
 test.c = 2.0;
 test.hola = "Hola"
 test.a = test:loles(test.b)
 funcion(test);
 

Codigo en lua a ejecutar

int funcion(lua_State *L){
    int n = lua_gettop(L);    /* number of arguments */
    printf("Numeros de argumentos %d\n",n);
    //printf("%s\n",luaL_typename(L,1));
    LuaType v1(L,1);
    Test t = (Test)v1;
    printf("Test.a = %d\n",t.a);
    printf("Test.b = %d\n",t.b);
    printf("Test.c = %f\n",t.c);
    printf("Test.hola = %s\n",t.hola);
    lua_settop(L,0); //borramos todo
    return 0;
};

Codigo en C++ de la funcion pasada a Lua

Y el nada glorioso resultado

El resto del codigo, no lo publicaré para no hacer más latoso este tema LOL (aunque si alguien desea, puedo publicar las modificaciones que le hice a Lunar)

Saludos!

template
class LuaType {
protected:
private:
    T valor; //!< Contiene el valor que estamos Wrappeando
public:
    /**
      * \brief Crea una nueva variable lista, para ser pasada a Lua
      */
    LuaType(const T t):valor(t) {};
    /**
      * \brief Extrae un valor en la pila, pero sin borrarlo
      */
    LuaType(lua_State *L,int i = -1);

    /**
      * \brief Pone este valor en la sima de la pila de Lua
      *
      * \param L estado actual de Lua
      */
    void pushValue(lua_State *L);

    /**
      * \brief Esta funcion permite recuperar el tipo original de la variable
      *
      * Ejemplo:

      * <code>
 * LuaType entero(5);
 * int variable_normal = (int)entero;
 * </code>
      * <code>
 * LuaType cadena("Hola Lua");
 * char *string = (char *)cadena;
 * </code>
      * \return el valor de la variable del tipo de este template
      */
    operator T() const {
        return valor;
    }

};

Primero lo que fue es crear una plantilla de una clase Wrapper, la cual me permitira extraer y colocar variables entre Lua y C++.

Usando especialización de templates (plantillas) podemos especificar como agregaremos cada tipo de variable en lua.

template<> LuaType::LuaType(lua_State *L,int i) {
    if(!lua_isnumber(L,i)) {
        luaL_error(L,"Argumento incorrecto");
    }
    valor  = lua_tointeger(L,i);
};

template<> LuaType::LuaType(lua_State *L,int i) {
    if(!lua_isnumber(L,i)) {
        luaL_error(L,"Argumento incorrecto");
    }
    valor  = static_cast(lua_tonumber(L,i)); // -1 top stack
};

template<> LuaType::LuaType(lua_State *L,int i) {
    if(!lua_isnumber(L,i)) {
        luaL_error(L,"Argumento incorrecto");
    }
    valor  = lua_tonumber(L,i); // -1 top stack
};

template<> LuaType::LuaType(lua_State *L,int i) {
    if(!lua_isstring(L,i)) {
        luaL_error(L,"Argumento incorrecto");
    }
    valor = const_cast(lua_tostring(L,i)); // -1 top stack
};

template<> LuaType::LuaType(lua_State *L,int i) {
    if(!lua_isuserdata(L,i)) {
        luaL_error(L,"Argumento incorrecto");
    }
    valor  = lua_touserdata(L,i);
};

Conviertiendo valores de la Pila de Lua a variables en C++

template<> void LuaType::pushValue(lua_State *L) {
    lua_pushinteger(L,valor);
}
template<> void LuaType::pushValue(lua_State *L) {
    lua_pushnumber(L,valor);
}
template<> void LuaType::pushValue(lua_State *L) {
    lua_pushnumber(L,valor);
}

template<> void LuaType::pushValue(lua_State *L) {
    lua_pushstring(L,valor);
}

template<> void LuaType::pushValue(lua_State *L) {
    lua_pushlightuserdata(L,valor);
}

Pasando las variables a Lua.

Parece que todo este código es muy engorroso, pero sin embargo nos facilitará más adelante para programar una clase proxy (la que nos facilitará el uso de estructuras o clases definidas en C++ en Lua)

Ejemplo:

#include <cstdio>
#include <cstdlib>
#include <EGa2D/Lua/Type.h>
#include <EGa2D/Lua/Member.h>

using namespace EGa2D;
using namespace Lua;

char *script = "print(string,entero)\nfuncion(entero,string)";

int funcion(lua_State *L){
    int n = lua_gettop(L);    /* number of arguments */
    LuaType<int> v1(L,1);
    LuaType<char *> v2(L,2);
    lua_settop(L,0); //borramos todo
    printf("%d %s",(int)v1,(char *)v2);
    return 0;
};

int main(int argc,char **argv){
    lua_State *L;
    L = lua_open();//abrimos lua
    luaL_openlibs(L); //con todas sus bibliotecas

    LuaType<int> entero = 5;
    entero.pushValue(L);
    lua_setglobal(L, "entero");

    LuaType<char*> string = "Holaaa";
    string.pushValue(L);
    lua_setglobal(L, "string");

    lua_pushcfunction(L,funcion);
    lua_setglobal(L, "funcion");

    if(luaL_dostring(L,script)){
        printf("Error %s\n",lua_tostring(L, -1));
    }

    if(L) {
        lua_gc(L, LUA_GCCOLLECT, 0);  // collected garbage
        lua_close(L);
    }

    return 0;
}

La idea de usar un Wrapper de los tipos de variables en C++ no es idea mía pero, lo vi programado en codigo que hacia lo mismo pero para una versión vieja de Lua. Así que quise probarlo y hasta el momento me ha traído algunos beneficios al programar (el código se vuelve más sencillo), y bueno espero poder terminar rápido, para poder implementarle scripting al juego y así volverlo más flexible a la hora de programar

Saludos

Vista en el editor Tiled. Lo rojo transparente indica que es colisionable

Gracias a esta capa extra y sin muchos problemas (habian unos problemas tontos, pero como siempre no más) pude añadirle la capa fisica que necesitaba el juego.

  Vista en el juego.

Aunque no todo era de color rosa, había algo que me incomodaba en ese momento. Tiled entregaba la capa fisica (los tiles de color rojo transpararente) como una matriz o una secuencia de 0 y 1.

Por ejemplo.

1,0,0,0,1,
1,0,1,0,1,
1,1,1,1,1

Pero box2D trabaja con rectangulos, circulos, lineas y polygonos y además tenia muchos problemas con la logica del juego como por ejemplo un fantasma que camina a lo largo de una plataforma no lograba caminar correctamente porque creia que su plataforma era más pequeña de lo que se veia. Entonces ¿Como podia pasar de las colisiones que estan en una matriz a muchos rectangulos?

Bueno como esa ocasión estaba apurado hice un algoritmo bastante ingenuo (sencillo o basico)

//codigo
uint16 *data; //es la matriz con los datos guardada en un arreglo
int layer_w,layer_h; // dimensiones de la matriz
//necesitamos procesar todos los rectangulos
        Rect **r = new Rect*[layer_w];
        for(int i=0; i<layer_w; i++) {
            r[i] = new Rect[layer_h];
        }
        //agregamos los datos en los rectangulos
        for(int y=0; y<layer_h; y++) {
            for(int x=0; x<layer_w; x++) {
                if(data[y*layer_w+x]) { //todo colisionable
                    r[x][y] = Rect(x,y,1,1);
                }
            }
        }
        //ahora aplicar el algoritmo ingenuo
        //!\todo optimizar el algoritmo ingenuo
        for(int x=0; x < layer_w; x++) {
            for(int y=0; y < layer_h; y++) {
                Rect a = r[x][y];
                if(a.width !=0 || a.height != 0) {
                    //buscar
                    for(int i=x; i<layer_w; i++) {
                        for(int j=y; j<layer_h; j++) {
                            Rect v = r[i][j];
                            if(v.width != 0 || v.height != 0) {
                                Rect suma = a + v;
                                //se pueden fusionar y son los mismos datos
                                if(suma.area() == a.area()+v.area() && data[layer_w*y+x] == data[layer_w*j+i]) {
                                    r[x][y] = suma;
                                    a = suma;
                                    r[i][j].width = 0;
                                    r[i][j].height = 0;
                                }
                            }
                        }
                    }
                }
            }
        }

Algoritmo sencillo en C++, se basa en crear una matriz de rectangulos de dimension 1×1 que reprensentan los 1s en las matrices y que pueden sumarse si hay algun rectangulo contiguo.

Luego en Box2D, consideraba los rectangulos que tuvieran Area distinto de 0 quedando esto.

Vista actual del juego después de la optimización

Lo que me permitia, que mis fantasmas u otro enemigo, pueda ver correctamente la plataforma y caminar a lo largo de ella.

Saludos

Cuando se llama LeerNivel en Contexto, lo que ocurre realmente este busca que Reader usar y finalmente lee el nivel con el Reader seleccionado.

Otro de los problemas que me tuve que solucionar era de como podia manejar los tantos niveles que podria tener, eso si la solución fue bastante estupida porque ya lo habia solucionado pero personalmente no aceptaba que deberia funcionar asi. Queria que un manejador de escena maneje muchas escenas, pero en vez de eso decidí que solo manejara una y que un algo superior manejara muchos manejadores de escenas, lo cual es mucho más limpio y ordenado según mi punto de vista. Lo más importante es que siempre mantengan simple y funcional su codigo.

Y el ultimo problema, aunque este solo fue copy and paste (jaja) es que cada actor podia modificar el entorno que lo rodea, entonces tenia que pasarle un puntero a Contexto.

En conclusión, mi motor no sera del todo poderoso y eficaz, pero se acerca cada vez a una version final y madura del mismo.

Saludos

Se agrego el comportamiento a los Powers Ups:

• PowerUp : El disparo es más rapido
• Vida: Añade una vida adicional
• Misil: Añade un misil a tu inventario
• Bomba: Añade una bomba a tu inventario

Bueno en este  resumen de 3 días, básicamente lo que se ha estado desarrollando son los componentes independientes para poder crear los Go (Game Object) y refinando alguno que otro detalle en el engine. Hasta ahora hemos obtenido buenos resultados. Siendo que ya tenemos algunos objetos listos todavía nos faltan otros por implementar. Lo más costoso que hemos tenido que realizar es crear los componentes desde 0, ya que algunos objetos requieren componentes más personalizados. Sin embargo, eso no es una traba muy grande para el desarrollo de un videojuego usando este concepto.

PS:Mi ortografia debe estar horrible :/

PS:La falta de desarrollo en mi editor lo convirtio en un CTRL+C  y CTRL+V de entidades (Go)

Se notaba a leguas que el carabinero queria sacarme un parte, pero gracias a mi padre que tenia todo en su vehiculo en comparación al jeep(el cual no esta operativo de hace tiempo) que no tiene nada de eso.

La razón de este post en mi blog es desconocida.

En en video siguiente mostrara algunas de las  cosas que ya se pueden hacer.

[yt]XusHlGmVCcA[/yt]

Todavía no he terminado este proyecto, además este video es algo viejo. Actualmente el editor es capaz de hacer lo siguiente.

• Copy/Paste (incluye imagenes hacia/fuera del programa)
• Trabajar con más de un nivel
• Cuadricula y Modo libre
• Zoom
• Cargar/Guardar/Guardar Comoo
• Otras caracteristicas pequeñas

Y más adelante me gustaria implementar (aunque para lograr esto debo trabajarlo conjuntamente con el engine)

• Capas
• Zonas
• Editor de Animaciones
• Scripting
• etc…

Bueno para no aburrirlos más me despido

Saludos nos leemos en el próximo post.

PS: Me gusto mucho el Windows Live Writer para escribir post, solo me falta un spell checker en español porque lo necesito ^^U

El siguiente código que les mostraré como transferir el archivo de la forma incorrecta, espero que al leerlo se de cuenta de cual es el error.

Primero debemos crear el servidor, primero el código para aceptar una simple conexión

ServerSocket server = new ServerSocket(1234);
Socket conexion = server.accept();

Básicamente lo que hacemos es crear un ServerSocket el cual se pone a la escucha en el puerto 1234 (un numero cualquiera pero debe ser superior a 1024). La siguiente linea lo que hace es esperar una conexión (esta función se bloquea hasta que alguien se conecte al puerto abierto) y devolverá un objeto Socket el cual manejará la conexión.

Luego debemos enviar el archivo (de la manera mala)

File transfer = new File("~/archivo pequeño.doc");
FileInputStream fin = new FileInputStream(transfer);
byte datos[] = new byte[fin.available()]; ///noten esto
fin.read(datos);
OutputStream out = conexion.getOutputStream();
out.write(datos);
out.flush();
out.close();
conexion.close();

Básicamente hemos transferido nuestro archivo de mala manera, pero también nos falta recibir nuestro archivo también de mala manera

Socket descargar = new Socket("localhost",1234);
InputStream in = descargar.getInputStream();
byte descarga[] = new bytes[in.avalaible()]; //noten esto
in.read(descarga);
FileOutputStream fout = new FileOutputStream(new File("~/archivo transferido.doc"));
fout.write(descarga);
descargar.close();

En las partes que les mencione en el código (noten esto) se darán cuenta que nuestro programa puede quedarse sin memoria al tratar de transferir un archivo muy grande.

Bueno espero que tengán deduzcan la forma correcta de transferir archivos antes que yo la postee, Saludos!!

Nota:Avisar si hay algún error, hice a la rapida este articulo :S

MiClase m = new MiClase();

Yo: Si, pero yo crearé un objeto y además llamaré un metodo usando Reflexión

Para este tutorial omitiremos ciertas cosas, para dar un primer paso con la reflexión y sea más fácil su compresión.

Para empezar necesitaremos una clase para probar la reflexión

public class MiClase{
  public MiClase(){
     System.out.println("Objeto contruido");
  }
  public void funcionSimple(){
    System.out.println("Funcion Simple");
  }
}

Empecemos entonces, como ya todos saben en Java casi todo es una clase (excepto los tipos primitivos, pero tienen una clase para convertir un int en Integer), entonces para nuestro caso necestaremos el objeto del tipo Class de MiClase

Class<?> clase = MiClase.class;

Notese que este metodo no es el unico para obtener la clase de un objeto, existen más que no describire aqui.

Object objecto = clase.newInstance();

Este metodo crea una nueva instancia de la clase que esta contenida en el objeto clase. Seguramente al ejecutar todo hasta aqui se daran cuenta que en la salida estandar dira:

Objeto contruido

que significa que todo esta bien.
Notar que: Esta función solo crea objetos si la clase tiene un contructor por defecto (sin parametros)

Ahora si deseamos llamar a una función sin parametros, la cual debemos obtenerla (todo esto ya se esta volviendo algo complejo)

Method m = clase.getMethod("funcionSimple");

La clase Method es una clase especial que nos permitira llamar a cualquier función definida en una clase, en este caso estamos obteniendo la funcion “funcionSimple” de MiClase

Y para finalizar el el tutorial

m.invoke(objeto)

Que llamará la función “funcionSimple” usando el objeto objecto creado anteriormente y al llamar esta funcion nos saldra en la salida estandar

Funcion Simple

El codigo completo de la clase Main con todo seria:

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * Clase que realiza toda el trabajo
 * @author egyware
 */
public class Main {

    public static void main(String[] args) {
        try {
            Class<?> clase = MiClase.class;
            Object objecto = clase.newInstance();
            Method m = clase.getMethod("funcionSimple");
            m.invoke(objecto);
        } catch (IllegalArgumentException ex) {
            ex.printStackTrace();
        } catch (InvocationTargetException ex) {
            ex.printStackTrace();
        } catch (NoSuchMethodException ex) {
            ex.printStackTrace();
        } catch (SecurityException ex) {
            ex.printStackTrace();
        } catch (InstantiationException ex) {
            ex.printStackTrace();
        } catch (IllegalAccessException ex) {
            ex.printStackTrace();
        }
    }
}

Como habran notado este tutorial es muy simple, pero les dara un primer acercamiento de como es la Relexión en Java.

Les dejo un link:
Un tutorial de Java: http://download.oracle.com/javase/tutorial/reflect/index.html (Sinceramente nunca lo he visto)