Bennu2Java 0.2

[proteo]

Actualizacion 04/05/2014

Hola, les traigo una nueva version de B2J, la misma incorpora algunas mejoras que detallo a continuacion

• MAP_INFO (Solo soporta G_WIDTH y G_HEIGH)
• PAUSE_SONG
• RESUME_SONG
• GET_ANGLE
• GET_DIST
• FGET_ANGLE
• FGET_DIST
• Ahora se pueden utilizar arrays
• Solucion a problemas en la generacion de funciones cuando se especificaba un tipo de retorno distinto de INT

Les dejo el link

https://mega.co.nz/#!CdNS0RDJ!EkN5zzEoIDENG2Qp1PXyLTDG2eL4lVfl9xPepm8xYBI

Saludos.

Actualizacion 27/04/2014

Buenas, ya con los problemas solucionados y el compilador reescrito les traigo la primera version no alpha de Bennu2Java (B2J de ahora en mas) las misma cuenta con

• Compatiblidad con fpg de 32 bits
• Compatibilidad con fnt de 8 bits
• Compatibilidad parcial con rutinas de reproduccion de sonido y musica
• Todas las capacidades que ya teniamos que hacen al lenguaje

Les detallo una lista de las instrucciones soportadas

• AND
• CASE
• DEFAULT
• ELSE
• ELSEIF
• FOR
• FRAME
• FROM
• FUNCTION
• IF
• LOOP
• OR
• PROCESS
• REPEAT
• RETURN
• SWITCH
• UNTIL
• WHILE
• INT
• FLOAT
• STRING

Rutinas de modulos

• ADVANCE
• COLLISION
• KEY
• LOAD_FNT
• LOAD_FPG
• LOAD_PNG
• LOAD_SONG
• LOAD_WAV
• PLAY_SONG
• PLAY_WAV
• SET_FPS
• SET_MODE
• SIGNAL
• TYPE
• WRITE
• WRITE_VAR

Para la carga y reproduccion de WAVs los archivos deben ser de 16 bits.

Paso a detallarles la instalacion del nuevo compilador

Primero: descarguen estos links y descomprimanlo
B2J:
https://mega.co.nz/#!HUMkjZpD!LV95SimJUgTZrBwONu8j-egDQD4u9e1Er979fYPoaps
Unzip:
https://mega.co.nz/#!7E8V0Q5L!0109qhF4Hzj4q6woq6OMcn8GUnt4RK_QwGQRT71wG18

Segundo: Descompriman el b2j.jar en la carpeta bin de Java por ejemplo "C:\Program Files\Java\jdk1.7.0_51\bin"

Tercero: Como antes, coloquen en alguna ubicacion de su preferencia los .jar que estan dentro de la carpeta "lib" del archivo descargado que son los siguientes

• gdx.jar
• gdx-backend-lwjgl.jar
• gdx-backend-lwjgl-natives.jar
• gdx-lwjgl.jar
• JDivBennu2Java.jar

Cuarto: copien el b2j.bat a alguna ubicacion de su preferencia

Quinto: seteen la variable de entorno "CLASSPATH" con el valor de la ruta "bin" de java y finalizado con ";" por ejemplo "C:\Program Files\Java\jdk1.7.0_51\bin;"

Sexto: agreguen a la variable de entorno "PATH" la ruta "bin" de java (Si es que ya no la tienen) y la rutina de donde copiaron el b2j.bat. Tambien agreguen a esta variable la ruta "bin" de donde descompriman el "unzip"

Una vez realizado todos estos pasos ya pueden ejecutar desde la linea de comando el b2j

b2j <programa a traducir> <ruta donde se alojaran los .java generados y el game.jar resultante> <ruta temporal> <ruta de las librerias>

Un ejemplo de la ejecucion del b2j

b2j d:\invasores.prg d:\Pruebas d:\Temp d:\PruebaJava\lib

En la pantalla van a aparecer un monton de cosas que son el log de las tareas de  b2j, seguido de la descompresion de los .jar de librerias en la carpeta indicada como temporal, terminando con la generacion del game.jar pero no le presten atencion a menos que algo termine con error.

Las tareas pendientes que tengo que espero solucionar a la brevedad son el tiempo de carga de los FPG que demora mas de lo que deberia y un problema de alineacion vertical con los textos que es casi imperceptible.

Ahora que todo se ejecuta por linea de comando se puede agregar facilmente (Para los que tengan el conocimiento :)) al Notepad++.

Tambien les paso los repos del b2j y del JDiv modificado

B2J
https://code.google.com/p/bennu2java/

JDiv modificado
https://code.google.com/p/bennu2javajdivlib/

Cualquier duda o sugerencia haganmelo saber.

Saludos.

Actualizacion 13/04/2014

Buenos dias, por fin he podido concretar una de las principales metas sobre este proyecto, ya esta lista la compatibilidad con FPG, los mismos deben ser si o si de 32 bits. Tengo que resolver un problema de tiempo de carga de los FPG pero ya funciona. Les dejo el link para el que lo quiera probar

https://mega.co.nz/#!jUEWUSKK!_SeWx3V3PGi05KjvMZC9eSrPbECYZpXJLoJjXrY0x6Y

Como la anterior entrega, contiene las librerias necesarias.


Cualquier bug por favor haganmelo saber.

Saludos.

------------------------------------------------------------------------------------------------




Actualizacion 12/04/2014

Hola Gente, como va? Aqui un nuevo Alpha de Bennu2Java, esta es la version 0.005a. En la misma ya se pueden utilizar

• Advance(n)
• Collision totalmente (Tanto con TYPE como con un ID de proceso como dentro de un if asignando al mismo tiempo a una variable el id o solo dentro de un if)

Hablando de variables con ID de proceso, esto ya lo comente en algun punto de este post pero lo agrego aca para que quede todo junto. las variables que vayan a guardar un Id de proceso, al declararlas se les debe indicar a continuacion del ; un comentario indicando que se trata de una variable para IDs de proceso, seria asi

Code Select Expand



int idProceso; // PID



el // PID le dice a Bennu2Java que se trata de una variable para guardar ID de proceso. Esto es necesario ya que en JDiv los id de procesos son Instancias de tipo ProcessJDiv y no un int.

Otra cosa a tener en cuenta para cuando trabajen con angulos y advance() es que en Bennu, los angulos se representan en milésimas y el JDiv en grados, por lo que habria que dividir por 1000 los valores que se estan utilizando en Bennu. Esto lo podrian hacer directamente sobre el codigo generado. En futuras versiones tratare de que esta conversion se haga automaticamante.

Les dejo el link, esta vez completo, dentro encontraran el Bennu2Java y una carpeta lib con las librerias necesarias. Solo deben configurar el .INI y listo.

https://mega.co.nz/#!zZ1VmYLK!m6L9FKuk4Rog03d5NmpnhcXAhXrfdX-czPV-I0b91_U

Saludos.

------------------------------------------------------------------------------------------------------------------

Actualizacion 09/04/2014

Buenas gente, como va? les traigo la version 0.004a, no agrega mucho, solo algunas instrucciones, les paso el resumen de instrucciones soportadas

• begin
• case
• const
• else
• elseif
• end
• float
• for
• frame
• from
• function
• global
• if
• int
• local
• loop
• private
• process
• repeat
• return
• string
• switch
• until
• while

Variables locales especiales

• mouse
• father

Rutinas

• load_png
• signal
• collision(solo pasando por parametro un id de proceso, luego tratare de solucionarlo, tengo problemas porque en Bennu, como es C/C++ una variable con un valor no negativo en un if se toma como una expresion verdadera. En java las unicas variables que se toman como expresion verdaderas por si solas son las boleanas. Por lo tanto la rutina Collision en bennu se puede utilizar para obtener el id de un proceso que colisiona como para verificar si una colision es cierta. Como veran en java esto se complica un poco pero ya vere como tratarlo).

esta lista ya la habia informado pero no habia pasado la version

les dejo el link

https://mega.co.nz/#!eJ03BRhK!WIy0KzyY2gyuk-biQ_F4Ya2zYLSrBpd3OhkLuDsPmAA

y les dejo el link de un zip con las librerias necesarias listas para usar

https://mega.co.nz/#!WRkXiaqQ!7K7E1NyxznTJnUpeNPThEV6EhYydKvUXWH8kf2X_6eQ

En fin, va tomando forma de a poco, pronto habra unos scripts para ejecutar todo el proceso desde Notepad++.

Saludos.

----------------------------------------------------------------------------------------------------------------------------------------

Actualizacion 06/04/2014

Buenas noches o dias segun del lado del globo que esten, les acerco la version 0.003a. Solamente consta de una mejora, se agrego funcionalidad para que genere un .jar ejecutable. Los requisitos para hacerlo

• Tener instalado el JDK y correctamente configuradas las variables de entorno (el bin de java agregado a la variable PATH y la variable JAVA_HOME con el directorio raiz de java)
• Contar con las librerias de LibGdx y JDivBennu2Java.jar que estan en ese mismo post.
• Tener configurado correctamente el archivo Bennu2Java.ini donde se indican la ruta de las librerias y una ruta temporal de uso EXCLUSIVO de Bennu2Java. Remarco lo exclusivo porque al momento de la generacion del .jar, el contenido de esta carpeta es completamente eliminado. De todos modos, si hay alguna ruta mal configurada Bennu2Java se los informa ya que verifica la existencia de cada archivo de libreria necesario.

Los pasos para la generacion del jar son los siguientes

• Seleccionar el .prg y generar su codigo java con el boton "Generar"
• Seleccionar un directorio destino para los archivos .Java en la seccion de salida.
• Seleccionar un directorio destino para el archivo.jar en la seccion de salida.
• Click al bonton "Generar Jar"

y listo, en la ruta que indicaron como destino para los jar encontraran un game.jar que luego pueden renombrar como gusten. Tengan en cuenta que deben copiar el jar en el mismo directorio donde esten generando los .dcb ya que ira a buscar las imagenes a la misma ruta que este ultimo. Una captura de la pantalla



y el link

https://mega.co.nz/#!zckgnLrK!G3nWRFaUuQKkMxMtAaqDOWuURfwx_OnC_D02lslVGUk

Este trabajo fue realizado por correcta recomendacion de Erkosone quien me sugirio la posibilidad de una conversion mas directa, de esta manera, sin mas trabajo ya pueden ejecutar su programa Bennu en version java (Obviamente dentro de las limitaciones que todavia presenta el Bennu2Java pero que con el tiempo cada vez seran menos.) Tambien habra una version en un futuro por linea de comando la cual podra ser configurada para lanzarla directamente desde Notepad++, tambien gracias a Erkosone por la idea.

En fin, lo dejo en sus manos.

Abrazo.

Actualizacion 05/04/2014

Hola Gente, les acerco el nuevo Alpha de Bennu2Java, el mismo incorpora soporte para declarar variables y utilizarlas. También la utilizacion de la variable father (por lo menos para obtener su X y su Y) y la posibilidad de que los procesos se envien señales a si mismos, por ejemplo, un disparo de una nave matandose a si mismo cuando su Y es menor a cero. Hablando de esto del Y, JDiv tiene el eje Y invertido por su compatibilidad con Box2D, asi que para las pruebas que hagan tengalo en cuenta. Durante este fin de semana voy a modificar el eje Y de JDiv para que quede todo tal cual, y le pondré algún flag por si alguno que utilizar Box2D. Tambien voy a tratar de incorporar la posibilidad de exportar a un proyecto Eclipse listo para importar y que se puedan enviar señales a otros procesos.

La único requisito, por lo menos mientras el programa este en desarrollo, es que sean estrictos al momento de programar. Con esto me refiero a

• NO declaren variables sin tipo.
• TODO bloque GLOBAL, LOCAL o PRIVATE terminenlo con su respectivo END.

Aqui les dejo el link

https://mega.co.nz/#!zIdgTJRS!NHbHM18GImRq2aEd9NxTrqj9--kYHv0gPeNJreJA8oE

En fin, jueguen con el y reportenme si encuentran bugs o si tienen sugerencias.

Saludos.

P.D.: Cuando le den a "Generar *.java" no les va a aparecer ningun mensaje, pero les aseguro que va a generar los archivos donde le indicaron.

Actualizacion

Buenas gente, aca les paso la primer Alpha de Bennu2Java, todavia no agregue la lectura de .FPG al JDiv pero con esta primera version se pueden hacer unas pocas cosas para que se den una idea de a que apunto

Actualmente estan soportadas las siguientes instrucciones y rutinas

• if
• for
• while
• loop
• frame
• exit
• key
• load_png
• mouse.x
• mouse.y
• mouse.left
• mouse.right
• set_mode
• set_fps

Tipos de datos (Aunque la declaración de variables no la inclui en este alpha, vendra en el siguiente, si es posible este fin de semana)

• int
• float
• string

El programa es bastante intuitivo



Aca les dejo los enlaces

Bennu2Java 0.001a

https://mega.co.nz/#!vVkT0IQa!Shyv246cT48W1tcygpsiRtXnLSgMpk_Dkn26Inx0ACs

Esta es la libreria de JDiv con una modificacion para que funcione el codigo generado con Bennu2Java

https://mega.co.nz/#!fIM3hALS!ksQay5r-B3bT5jy-D_lzAs3ojcz6YBuPLzY88Bkh-wA

A su proyecto tambien tendran que agregar los .jar de libgdx que estan en los ejemplos de JDiv, los pueden descargar de este enlace

http://sourceforge.net/projects/jdiv/files/JDiv%20API/JDiv%201.0/

Para ejecutar su codigo creen un proyecto java normal en Eclipse, luego creen una carpeta "lib" en el mismo y copien el JDivBennu2Java.jar y los .jar de LibGdx que se encuentran en los ejemplos de JDiv (Una vez descomprimidos los ejemplos, hay una capeta que se llama libs). Resumiendo, estos son los .jar que necesitan en su proyecto.

• gdx.jar
• gdx-backend-lwjgl.jar
• gdx-backend-lwjgl-natives.jar
• gdx-natives.jar
• JDivBennu2Java.jar

Una vez copiados los .jar, los seleccionan a todos, le dan click derecho->build paths->add to buils path.

Luego copian los .Java generados con el programa a "src" en el proyecto eclipse y ejecutan el Launcher.java.

Voy a hacer el esfuerzo para que la proxima revision tenga un boton para exportar un proyecto eclipse listo para ser ejecutado.

Por favor si encuentran algún bug, que los debe haber a montones, reportenmelos asi los voy solucionando y vamos puliendo el programa. Disculpen lo limitado de esta entrega pero queria darles algo para que vayan viendo de que va la cosa.

Saludos.

------------------------------------------------------------------------------------------------------------------------------------------------------------------

Hola Gente, como va? resultado de la necesidad, estoy trabajando en un videojuego para Android con Bennu, lenguaje que me atrapo al igual que DIV en su momento. El problema con el que me encontré es la fluidez de los movimientos cuando corro el juego en mi movil, el cual mueve a la perfección otros proyectos que he encarado con un framework para java llamado LibGdx. Seguido a esto, paseando por este foro por casualidad me encontre con JDiv, un framework muy piola que se apoya en LibGdx y que sigue muy bien la filosofia de DIV.

Todo este conjunto de sucesos me impulso a encarar un proyecto que me va a servir para solucionar el problema de la fluidez y que cuando este en condiciones compartirlo con ustedes. Se trata de un traductor de Bennu a Java. Mas específicamente, el objetivo de este proyecto es desarrollar un programa que toma como entrada tu programa bennu, ya probado y funcionando, y lo traduce a su equivalente en java con JDiv y LibGdx. De esta manera, llevando los archivos generados a un proyecto Java Android en eclipse, poder compilar el proyecto y conseguir un incremento en la velocidad.

Lo que he conseguido hasta ahora es procesando este codigo

Code Select Expand


program prueba;


process Main()

private


end

begin

set_mode(640,480,32);

nave(320,240);

loop

frame(2000);

end

end


process nave(x,y)

begin

file = fpg_graficos;
graph = 5;

loop

if (key(_left))

x-=10;

end

if (key(_right))

x+=10;

end

if (key(_up))

y-=10;

end

if (key(_down))

y-=10;

end

x = mouse.x;
y = mouse.y;

frame;

end

end


y al procesarlo con Bennu2Java obtenemos

Code Select Expand


public class Main extends ProcessJDiv {
public Main(){
}


@Override
public void code() throws InterruptedException {


JDiv.scene.setMode(640, 480);



new nave(320,240);

while(true){



frame(2000);

}



}



@Override
public void dispose() {}
}
public class nave extends ProcessJDiv {
public nave(int x,int y){
this.x = x;
this.y = y;
}

@Override
public void code() throws InterruptedException {


file=fpg_graficos;
graph=5;

while(true){



if( JDiv.input.key(Keys.LEFT) ) {

x-=10;


}



if( JDiv.input.key(Keys.RIGHT) ) {

x+=10;


}



if( JDiv.input.key(Keys.UP) ) {

y-=10;


}



if( JDiv.input.key(Keys.DOWN) ) {

y-=10;


}


x=JDiv.input.getTouchScreenX() ;
y=JDiv.input.getTouchScreenY() ;


frame();

}



}

@Override
public void dispose() {}
}



Obviamente que pretendo que se genere con las tabulaciones. No les paso una Beta porque recien me estoy incursionando en el procesamiento Lexico y tengo bastante cosas que pulir, pero nada que no pueda resolver. Ni bien tenga una version estable la comparto.

Por otro lado tengo dos puntos a desarrollar y adicionar a lo que ofrece JDiv. Estos serian la deteccion de colisiones "Pixel Perfect" como la que tiene Bennu y poder trabajar con los archivos .fpg directamante, en lugar trabajar con los altlas que utiliza y poder conseguir mayor compatibilidad.

El objetivo final es desarrollar una herramienta que dado un programa desarrollado en nuestro comodo y genial Bennu obtengamos un apk instalable en android o incluso, y esto lo debo investigar, generar un proyecto para integrar en eclipse.

En fin, ni bien tenga una version utilizable la compartire con ustedes.

Saludos.

[emov2k4]

Excelente trabajo, espero una beta pronto !! Saludos

[Ruter106]

Interesante desarrollo!!

¿Lo piensas enfocar sólo a Android o a Java en general?

Enviado desde mi GT-I9001 usando Tapatalk 2

[proteo]

Interesante desarrollo!!

¿Lo piensas enfocar sólo a Android o a Java en general?

Enviado desde mi GT-I9001 usando Tapatalk 2

El programa genera código Java. Este código Java utiliza JDiv como framework. JDiv utiliza como framework LibGdx. LibGdx es multiplataforma. Asi que sin cambiar el código mas que la clase principal debería funcionar en cualquier plataforma.

Mi experiencia trabajando con LibGdx, mis desarrollos, sin modificacion mas que una linea en la clase principal, funciona tanto en PC (Probado en Windows, Linux y Mac) como en Android.

Ni bien tenga una versión funcional se las paso.

Saludos.

[KeoH]

Mola ... yo estube juegueteando con libGdx hace unos meses y la verdad que me moló bastante .. si no la uso es porq java me cae un poco antipatico jajaja pero mola. Animo ;D

[proteo]

Mola ... yo estube juegueteando con libGdx hace unos meses y la verdad que me moló bastante .. si no la uso es porq java me cae un poco antipatico jajaja pero mola. Animo ;D

A mi tambien me molesta un poco Java para programar videojuegos, ya que si bien me muevo con soltura con el lenguaje, me molesta un poco ya que se pierde tiempo lidiando con cosas del lenguaje en vez de enfocarlo al 100% a lo que estas haciendo que es programar un videojuego. Si esto me sale como espero, seria Genial programar con BennuGd y tener un programa Java como resultado, con el beneficio en la velocidad que esto significa. Actualmente estoy modificando los fuentes de JDiv para agregarle algunas cosas.

Para contarles en vivo, estoy descomponiendo un .png en una matriz y lidiando con toda la mierda de la aritmetica de matrices para poder agregarle a JDiv la deteccion PixelPerfect como tiene BennuGd. Una vez que consiga esto voy a por la carga de .fpg (Me baje el codigo C de BennuGd, siempre tuve problemas para leer el codigo C de otra persona ya que muchos empiezan a jugar con las macros y termina siendo un lio seguirlo XD, pero todo sea porque esto llegue a buen puerto) e invertir el eje Y ya que JDiv lo tiene como libgdx por una cuestion del motor de fisica Box2d.

En fin, hitos que espero ir resolviendo sin mayores percanses.

LibGdx en un buen framework. Soluciona muchisimos aspectos de la programacion de videojuegos en Java. Cuando me inicie en la programacion de videojuegos para android lei un libro del creador de libgdx, Mario Zechner, en el cual te explica paso a paso como ir desarrollando un framework para juegos en android el cual es 80% igual a la version actual de LibGdx por lo que lo conozco bastante a fondo.

Ni bien haya novedades los mantengo al tanto.

Saludos.

[proteo]

Buenas gente, les paso un poco el status del asunto, deje un poco en stand by el traductor de codigo para dedicarme a agregarle dos funcionalidades al JDiv, ya tengo funcionando la deteccion de colisiones a nivel pixel y la carga de archivos fpg, con esta ultima tengo un problema que hay un color que no me levanta pero nada, ya lo solucionare. Ahora tengo que hermanar esta funcionalidades a JDiv y luego continuar con el traductor. Espero poder pasarles un alpha el fin de semana.

Saludos.

[Ruter106]

Ya vas rápido!!! :)

Enviado desde mi GT-I9001 usando Tapatalk 2

[KeoH]

Cuando me inicie en la programacion de videojuegos para android lei un libro del creador de libgdx, Mario Zechner, en el cual te explica paso a paso como ir desarrollando un framework para juegos en android ....

Cual libro? este? xDDD yo lo tengo tambien.

[proteo]

Cuando me inicie en la programacion de videojuegos para android lei un libro del creador de libgdx, Mario Zechner, en el cual te explica paso a paso como ir desarrollando un framework para juegos en android ....

Cual libro? este? xDDD yo lo tengo tambien.

Exactamente el mismo  ;D.

[proteo]

Buenas gente, como va? les cuento un poco como viene el asunto.

• He logrado levantar FPGs de 32 bits en java por lo que es inminente que lo integre con JDiv.
• El traductor viene de maravilla, estoy lidiando con algunas particularidades (los comentarios en el codigo Bennu me hacen lio XD)
• Estoy haciendo una rudimentaria interfaz donde se puede elegir el programa Bennu, procesarlo y muestra una lista con todos los procesos y el codigo generado para cada uno.
• Posible exportacion a proyectos Eclipse, por lo que solo tendrias que importarlo desde eclipse y ya esta, esto ultimo lo estoy evaluando.
• Por el momento abandono la idea de la deteccion de colisiones PixelPerfect ya que la pude implementar y por mas que optimice por todos lados y todo lo que mis conocimientos me lo permitieron pero consumia demasiados recursos. Por ahora voy a encarar para una futura version la generacion automatica de poligonos aproximados a la forma del sprite. De todos modos no descarto el metodo PixelPerfect, luego de que les de una version de esta aplicacion utilizable, voy a investigar NDK para realizar una rutina en C navita que realice el tema de la deteccion de colisiones y poder invocarla desde java, en teoria mejoraria el tiempo de respuesta.

En fin, la version 0.01 esta cerca de ser una realidad. Esten atentos :D

[Erkosone]

Genial Proteo, me alegro que lo hayas resuelto en tan poco tiempo, todo esto pinta muy interesante la verdad.


Haber si logras sacar algo para probar, yo me apunto ;)

[proteo]

Ya esta el primer alpha, el fin de semana les paso una version mas robusta y con un par de cosas que no active porque estoy resolviendo unos temas de expresiones regulares para analizar el codigo fuente de Bennu. Al principio de este hilo tienen los detalles y los enlaces de descarga.

Saludos.

[Erkosone]

Hola Proteo, me encanta esta iniciativa, LibGDX anda como un ferrari en Android, he probado esa lib y la aceleración por hardware que ofrece y es una pasada.


Si aceptas sugerencias para ampliar un poco las caracteristicas base de bennuGD yo me ofrezco a comentarte varios aspectos que pueden resultar muy interesantes y prácticos.


Dale caña, esto promete mucho, cuanta conmigo para ir testeando a fondo, en cuanto se puedan definir variables me pongo a probarlo.


Como sugerencia, podrías pensar la forma en que montar un sistema de reescalado automático, eso sería muy útil, nos dejaría programar en cualquier resolución y luego el propio proyecto se ajustaría al dispositivo real.

[proteo]

Hola Proteo, me encanta esta iniciativa, LibGDX anda como un ferrari en Android, he probado esa lib y la aceleración por hardware que ofrece y es una pasada.


Si aceptas sugerencias para ampliar un poco las caracteristicas base de bennuGD yo me ofrezco a comentarte varios aspectos que pueden resultar muy interesantes y prácticos.


Dale caña, esto promete mucho, cuanta conmigo para ir testeando a fondo, en cuanto se puedan definir variables me pongo a probarlo.


Como sugerencia, podrías pensar la forma en que montar un sistema de reescalado automático, eso sería muy útil, nos dejaría programar en cualquier resolución y luego el propio proyecto se ajustaría al dispositivo real.

Muchas gracias por el apoyo. Te comento que como esta al dia de hoy ya se reescala automaticamente, si bien se genera el codigo para que quede seteado en la resolucion que establece set_modo, en Launcher.java se puede cambiar la resolucion y en teoria quedaria escalada, un punto para testear. Lo de las variables casi esta, tengo que limar unas asperezas.

Saludos.