Actualizacion 04/05/2014Hola, 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/2014Buenas, 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/2014Buenos 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/2014Hola 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
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/2014Buenas 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
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/2014Buenas 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
(http://thumbs.subefotos.com/de6b63bf07dcd4b8434f09343ae63fb7o.jpg) (http://subefotos.com/ver/?de6b63bf07dcd4b8434f09343ae63fb7o.jpg)
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/2014Hola 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.
ActualizacionBuenas 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)
El programa es bastante intuitivo
(http://thumbs.subefotos.com/c8c5d5a8b28c4732a28f56d199f4a2c5o.jpg) (http://subefotos.com/ver/?c8c5d5a8b28c4732a28f56d199f4a2c5o.jpg)
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
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
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.
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
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.
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 ;)
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.
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.
Agrego la posibilidad de generar .jar ejecutables directamente desde Bennu2Java ;D, En el primer post del hilo encontraran toda la info necesaria.
Saludos.
Bueno, probado.
Haber, he metido todo lo necesario en la ruta: c:\B2J\ "con la ultima versión de LibGDX 1.0".
He configurado el path temp y lib en el archivo ini.
Al ejecutar tu aplicación busco el archivo prg, le doy a generar java y me genera correctamente los archivos java, luego le doy a generar JAR y no me lo genera pero no me da error.
Que puede ser?
Oye proteo, te propongo algo haber si lo ves bien y quieres implementar una prueba de esta manera.
Muchos o practicamente todos trabajamos con Notepad++, es una herramienta libre y buena, por que no haces simplemente 2 bats para:
1 - Compilar, empaquetar y ejecutar "en windows".
2 - Compilar, empaquetar e instalar "en Android".
Podríamos partir de una base bien simple como esta:
Estructura de un juego cualquiera programado en bennuGD:
.\MyGame
\data
Osea, simplificando al máximo, el juego programado en BennuGD está dentro de un folder llamado "MyGame" o cualquier otra cosa, pero imperativamente y a excepción del archivo/s .prg todo recurso del juego/aplicación deberá estar contenido en la sub carpeta "data".
Osea:
myJuego.prg
data\main.fpg
data\music_1.ogg
etc etc etc...
Entonces simplemente con llamar a tus bats desde el notepad así: B2Jwin.bat "c:\bennugd\projects\MyGame\MyJuego.prg" ya estaría todo listo.
Sería crear un paquete con todo lo que va a hacer falta, librerías, bats etc etc.. y añadir 2 accesos directos al notepad++, sería mas cómodo que ejecutar una aplicación externa y andar buscando directorios y eso.
Sobre donde guardar el .apk, .jar o .java, pues al ejecutar el bat, en la misma carpeta del juego se crea una sub carpeta llamada "binaries" y dentro de ella otra llamada "release" y ale.. tood lo que se cree con tu sistema se queda ahí.
Que te parece la idea?
Buenas, una aclaracion que no hice cuando subí la nueva version, cuando definan una variable que va a albergar un ID de proceso, Bennu2Java necesita que se le indique que esa variable es para un Id de proceso de la siguiente forma
Ejemplo
int id_proceso; // PID
Agregando ese comentario a continuación basta. En este momento estoy trabajando sobre JDiv para poder utilizar los FPG, estoy tratando de que estos archivos no requieran conversión previa.
Saludos.
Buenas noches, como va? En estos dias voy a estar subiendo la primera version 0.1, con esto Bennu2Java deja su fase Alpha. La misma deja el GUI con el que contaba para manejarse integramente por linea de comando. Estoy tratando de solucionar un problema con los WRITE pero pronto ya lo tendre. Para esta version he reescrito el compilador haciendo uso de herramientas que hacia mas facil y optimo el parseo de codigo. Como comente antes, esta version contara con soporte para FNT de 8 bits. Esto sumado al soporte de FPG de 32 bits y casi todo el lenguaje basico mas algunas rutinas de libreria implementadas hacen a Bennu2Java ya funcional donde cualquier juego sencillo que no realice creacion dinamica de mapas, ni uso de regiones podra ser traducido y ejecutado.
Tambien ya que estoy queria soliticar a quien lo desee ser tester de este proyecto para tratar de pulirlo lo mejor posible. Esto solo implicaria que cualquier novedad que haya sobre el desarrollo sera notificada por MP o buscar algun canal de comunicacion mas fluido.
En fin, como ya dije en algun momento, espero avanzar lo suficiente y llegar a una etapa lo mas madura posible para tener una buena herramienta para todos.
Saludos.
Ya esta la version 0.1, ya no es alpha :).
Saludos.