DESARROLLO SOFTWARE - Proyectos de DarkRyoga

1, 2, 3, 4, 5
Spartark escribió:Espero que no tardes mucho en subir la siguiente lección.


Espero tener preparada la nueva entrada la semana próxima.
¿es posible utilizar la libreria GBT player para que una música en concreto se cargue en un banco de memoria distinto al de por defecto?
Spartark escribió:¿es posible utilizar la libreria GBT player para que una música en concreto se cargue en un banco de memoria distinto al de por defecto?


Al usar GBT Player por defecto la melodía se generará para ser cargada en el banco de memoria 2. Si quieres que al generar el fichero .C este luego sea cargado en un banco de memoria distinto tienes que hacerlo a la hora de compilar de la siguiente manera.

mod2gbt .\mods\cancion.mod song -c 3


En este ejemplo conseguirás definir la melodía en el banco de memoria 3. Luego para cargarla sólo tienes que usar las funciones que ya comenté en su momento:

SWITCH_ROM_MBC1(3);


Y lamento la demora a la hora de continuar con los tutoriales pero he estado bastante ocupado las últimas semanas. La siguiente entrada estará disponible como muy tarde el próximo fin de semana.

Saludos.
Gracias por la respuesta, he probado a usar la herramienta mod2gbt como indicas y luego a cargar la música en otro banco diferente al segundo y funciona. Espero con ganas la siguiente entrada.
TUTORIAL DE PROGRAMACIÓN PARA GAME BOY - PARTE #8: Fuentes de texto / Texto con Formato

Imagen

Después de varias semanas de inactividad vuelvo para continuar con los tutoriales. En este caso se va a tratar de un tutorial muy sencillo donde aprenderemos a mostrar en pantalla texto de forma bastante fácil. Para ello os facilitaré el código fuente de la función principal que utilizo para este cometido. Además os dejo a continuación el resultado del trabajo de esta entrada en formato video como de costumbre:

PREDATOR (DEMO) - GAME BOY COLOR DEMO [GAMEBOY COLOR HOMEBREW] Game Boy C Programming
https://www.youtube.com/watch?v=0Iuzb8yL3gg

La descripción del video en la que explico un poco el proceso que he llevado a cabo para juntar imágenes, texto y audio:

"PREDATOR (1987) - (PRE-DEMO) is a homebrew demo for Game Boy programmed using the "Game Boy Development Kit" (GBDK) in C programming language.

This demo uses a lot of screen captures from the PREDATOR Game for NES/FAMICOM and combine them with the main music theme from the game "Alien Vs Predator: The Last of his clan" for Game Boy. The main music theme from "Alien Vs Predator: The Last of his clan" has been reaped into .gbs file format and has been converted into a .MOD file using the software "DEFLEMASK" and finally converted in a .C file using the GBT Player library for gameboy and loaded and played in the demo using bank switching and MBC1 memory controller."


Existen varios métodos por los cuales podemos usar fuentes de texto con formato en los juegos que desarrollemos para game boy. En esta nueva entrada yo explicaré un poco el que creo que es el más asequible. De entrada lo que haremos será usar una fuente de texto cómo por ejemplo esta:

Imagen

La jugada es la siguiente. Si recordáis en los primeros tutoriales donde aprendimos a manejar imágenes os hablé de un conversor de imágenes a ficheros .c/.h muy útil y accesible vía web: http://www.chrisantonellis.com/gameboy/gbtdg/. Lo que tenéis que hacer es meter la imagen con la fuente en dicho conversor. En principio nos vale la imagen tal cual sin optimizaciones así que se pueden desmarcar las opciones Tile Quantization y Generate Tile Map y seleccionaremos como formato de salida C Format (GBDK). El contenido generado lo almacenarmos en un fichero .c, por ejemplo "font.c" en donde estarán almacenados los tiles de la fuente en formato ASCII. A continuación utilizaremos la función "pintar_cadena_de_caracteres()"

#include <gb/gb.h>
#include "font.c"
#include "images/preDEMO2.h"

// posicion de los tiles del texto
#define FONT_OFFSET 128

/////////////////////////////////////////////////////
//
//  void pintar_cadena_de_caracteres()
//  Si flag vale 0 entonces pinta la cadena en BKG
//  si vale 1 entonces pinta la cadena en WIN. Es necesario
// en este último caso activar la ventana donde se va a
// mostrar el texto con SHOW_WIN;
//
/////////////////////////////////////////////////////
void pintar_cadena_de_caracteres( char *cadena, UBYTE px, UBYTE py, UBYTE flag ){

    UBYTE posx, strx, nextlen;
    UBYTE posy, e;
    UBYTE c;

    strx = 0;
    posx = px;
    posy = py;

    // mientras la cadena no termine
    while(cadena[strx] != 0){

        // comprueba la longitud de la palabra actual de la cadena
        nextlen = 0;
        for( e = strx; (cadena[e] != ' ') && (cadena[e] != 0); e++)
            nextlen++;

        // si el texto no entra en la linea actual entonces saltamos a la siguiente línea
        if ( posx + nextlen > 20){
            posx = 0;
            posy++;
        }

        // pinta la palabra en la posicion que le corresponde
        for(;(cadena[strx] != ' ') && (cadena[strx] != 0); strx++){
            c = cadena[strx] + FONT_OFFSET - 32;
            if( !flag )
                set_bkg_tiles( posx, posy, 1, 1, (unsigned char *) &c);
            else
                set_win_tiles( posx, posy, 1, 1, (unsigned char *) &c);
            posx++;
        }

        // pintar un espacio en blanco entre las palabras de la cadena
        if ( posx != 0 ){
            c = ' ' + FONT_OFFSET - 32;
            if( !flag )
                set_bkg_tiles( posx, posy, 1, 1, (unsigned char *) &c);
            else
                set_win_tiles( posx, posy, 1, 1, (unsigned char *) &c);
            posx++;
        }

        // si no es el final de la cadena incrementamos la posicion
        if(cadena[strx] != 0 )
          strx++;
    }
}

void PLOT_BACKGROUND_IMAGE(int coord_X, int coord_Y, int tam_tile_X, int tam_tile_Y, unsigned char *tile_data, unsigned char *map_data, int millis){
   set_bkg_data(coord_X, coord_Y, tile_data);
   set_bkg_tiles(coord_X, coord_Y, tam_tile_X, tam_tile_Y, map_data);
   SHOW_BKG;
   DISPLAY_ON;
   delay(millis);
}

void main(){

    PLOT_BACKGROUND_IMAGE(0, 0, 20, 18, preDEMO2_tile_data, preDEMO2_map_data, 1);
    set_bkg_data( FONT_OFFSET, 64,(unsigned char *)font);

    pintar_cadena_de_caracteres("MAJOR DUTCH SCHAEFER", 0, 12, 0);
    pintar_cadena_de_caracteres("AND HIS COMMANDOS", 0, 13, 0);
    pintar_cadena_de_caracteres("FLY DEEP INTO THE",0,14,0);
    pintar_cadena_de_caracteres("JUNGLE TO",0, 15,0);
    delay(5000);

     //// .......
    //// .......
    //// .......
    //// .......

    // muestra el BKG
    SHOW_BKG;
   
    while(1){
    }
}


Como podéis apreciar todos los casos para el texto de entrada están contemplados para la función pintar_cadena_de_caracteres() por lo que si la palabra que va a pintar no cabe en la línea actual la pinta en la siguiente. El resto de funciones como la de pintar una imagen de fondo ya la vimos en entregas anteriores.

Lo único que me quedaría por comentar es el tema de las ventanas. Si no queréis andar recortando imágenes para hacer hueco al texto que queréis mostrar superpuesto os recomiendo usar ventanas en lugar del fondo. Al usar SHOW_WIN; en lugar de SHOW_BKG; activaremos una ventana que tiene el mismo tamaño que el fondo, con la particularidad de que la podemos mover y colocarla en la posición (x,y) que nos convenga con la función move_win(x, y) que proveé GBDK (creo que forma parte del gb.h sino buscadla porque estará en otro fichero .h de la distribución del entorno de desarrollo). De esta forma se hace mucho más fácil mostrar texto en imágenes sin retocar abriendo y cerrando ventanas. De hecho las ventanas se utilizan para diversos efectos en multitud de juegos en Game Boy. Así a bote pronto se me ocurren los juegos de la saga MegaMan (saga clásica) en este sistema. El inventario con los poderes de los "Robot Master" que Mega Man adquiere tras cada enfretamiento es un menú que aparecía al pulsar el botón START. Pues bien ese menú emergente podría implementarse con una ventana (previamente habría que salvar en algún lado el contenido del fondo puesto que BKG y WIN comparten los datos), y si lo recordáis no sólo aparecía texto, sino también aparecían sprites más complejos en ella, así que imaginaros las posibilidades que tiene el uso de ventanas de forma conveniente.

Por mi parte poco más tengo que añadir en esta entrada, cómo podéis apreciar con un poco de maña no debería resultar muy difícil programar una aventura conversacional usando estas técnicas. Espero poder volver dentro de poco con la siguiente la cual versará sobre los programas GBMB y GBTD.

Saludos.
Buen curro tio, la DEMO pinta de maravilla. ¿Podrías intentar explicar un poco más el tema del banking para ir cambiando los datos de las imágenes que muestras?
Spartak si puedo echarte una mano con lo del banking pregunta e intentaré responderte dentro mis limitaciones xD.

Imagino que Ryoga el pobre andará liado.
Respecto al ejemplo de GBT. Está mal. Bastante mal. Fallos:

1 - Fallo menor: SWITCH_ROM_MBC1() -> No es necesario usar esto antes de llamar a gbt_play().

2 - Fallo WTF:
if(gbt_update_released == 0){
   gbt_update_released = 1;
   add_VBL(gbt_update);
}

No se que leches buscabas con eso, pero está rematadamente mal. Con llamar add_VBL(gbt_update); al principio del código es suficiente. Si no, estás añadiendo llamadas a la función inutilmente. add_VBL() sirve para que cada vez que se llega al VBL se llamen a todas las funciones que has añadido con add_VBL, no creo que GBDK busque duplicados al añadir rutinas de control de interrupciones.

Además, hay otro pequeño problema, esto de llamar a gbt_update directamente desde la rutina de interrupción puede dar problemas si usas varios bancos.

Correción: poner gbt_update(); justo antes de wait_vbl_done(); y listo. O después, casi mejor.

Mas info: http://antoniond_blog.drunkencoders.com/?p=392

EDIT: Vale, el fallo 2 no es tan fallo porque solo se llama una vez, pero es una tontería hacerlo así, es suficiente con ponerlo al principio del main().
SkyLyrac escribió:Respecto al ejemplo de GBT. Está mal. Bastante mal. Fallos:

1 - Fallo menor: SWITCH_ROM_MBC1() -> No es necesario usar esto antes de llamar a gbt_play().

Mas info: http://antoniond_blog.drunkencoders.com/?p=392


EDIT: Vale, el fallo 2 no es tan fallo porque solo se llama una vez, pero es una tontería hacerlo así, es suficiente con ponerlo al principio del main().


Gracias por las indicaciones. Nunca antes había usado un player para GBDK aunque tampoco sé si existen otros.
DarkRyoga escribió:Gracias por las indicaciones. Nunca antes había usado un player para GBDK aunque tampoco sé si existen otros.

Está el Carillon Player, pero no es fácil usarlo en GBDK, viene como un .bin que hay que incluir, y hay que hacer algunas cosas raras para llamar las funciones del player. También estaba el Lemon Player, pero está en C y es mucho más limitado que el GBT. Me tiré como una tarde optimizando hasta que vi que la cosa no tenía remedio y decidí empezar el GBT. De hecho, la idea de utilizar un .mod y un conversor lo copié del Lemon. A parte de estar en C, el principal problema es que el diseño del código dejaba mucho que desear para tener varias canciones y cosas así, y nunca llegó a sacar la versión 2 que prometió...

En cuanto al Carillon, el problema es que es más incómodo de hacer música, sobre todo porque solo puedes hacerla desde una ROM de GB, por eso me gusta más mi sistema, solo necesitas un tracker de PC o de lo que quieras. Por otra parte, el Carillon se puede permitir algunos efectos extra ya que no tiene que simularlos a través de comandos del .mod, y sabes como va a sonar exactamente porque lo estás haciendo directamente en hardware/emulador. Pero bueno, en mi caso personal me merece más la pena esa comodidad extra, el Carillon me parece más algo en plan LSDJ, para chiptuneros.
Mola un cojón la demo de "PREDATOR" tio. Para practicar con las cadenas de caracteres está bastante bien. Así además repaso algo de los backgrounds que hace tiempo que no seguía el tutorial.

Un saludo.
Spartark escribió:Buen curro tio, la DEMO pinta de maravilla. ¿Podrías intentar explicar un poco más el tema del banking para ir cambiando los datos de las imágenes que muestras?


En estas DEMOS siempre utilizo la misma técnica con el bank switiching. Para mostrar una imagen lo que hago es convertirla primero con el conversor que llevo usando desde el principio de los tutoriales para obtener un fichero de cabecera .h. Para estos casos en concreto luego lo que hago es renombrar dicho fichero a .C para compilarlo de forma separada del resto, por ejemplo así:

lcc -Wf-bo2 -c -o  imagen_0.o ./images/imagen_0.c


Donde el número que acompaña al flag -Wf-bo2 me dice el banco de memoria desde donde puedo recuperar luego la información (en este ejemplo el banco 2). Una vez que tengo todas las imágenes que quiero, defino las estructuras de datos de las mismas dentro de mi main.c como extern, por ejemplo así:

extern const unsigned char imagen_0_map_data[];
extern const unsigned char imagen_0_tile_data[];


A la hora de compilar el main junto con los datos que se cargan desde lo bancos lo que hago es ejecutar una línea similar a esta (por poner un ejemplo):

lcc -Wa-l -Wl-m -Wl-j -DUSE_SFR_FOR_REG -Wl-yt1 -Wl-yo32 -Wl-ya0 -o imagenes-gbDEMO-MBC1BankSwitching-2015xxxx.gb rom.o .imagen_0.o imagen_1.o imagen_2.o imagen_3.o datos_0.o musica_0.o


Y luego por código cuando voy a utilizar un recurso que se necesita cargar desde un banco de memoria utilizo la función que ya he comentado en alguna ocasión, justo antes de empezar a operar con las estructuras de datos definidas previamente y que tienen esa información:

SWITCH_ROM_MBC1(x);


Donde la x en este caso se corresponde con el número de banco de memoria que me interesa. Esta es la forma de operar a grandes rasgos que he estado utilizando tanto en la demo de "PREDATOR" como en la demo de "Batman":

Imagen

BATMAN (1989 DEMO) - GAME BOY COLOR DEMO [GAMEBOY COLOR HOMEBREW] Game Boy C Programming

https://www.youtube.com/watch?v=JZXKO3kF4QY

En ambos casos utilizo este tipo de técnica para cargar los datos que son de interés y que voy a usar en cada momento.

Disculpad por la ausencia pero he estado bastante liado. Espero poder traer dos nuevos juegos dentro de poco. Ambos son jugables a día de hoy pero me falta por añadirles algunos detalles antes de que vean la luz.

Saludos.
Pura crema.

Con calma Ryoga ;)
Gracias. Ahora me ha quedado más claro.
TUTORIAL DE PROGRAMACIÓN PARA GAME BOY - PARTE #9: Crear Efectos Visuales usando Scan Lines

Imagen

Tras un tiempo de inactividad vuelvo a la carga con una pequeña entrada relacionada con la programación para Game Boy. Echadle un ojo al siguiente video.

https://www.youtube.com/watch?v=Cb80ilm2xcY&index=7

Cómo creo que ya he comentado por aquí la game boy dibuja en la pantalla linea a linea. En el mundillo estas lineas son conocidas como "scan lines" y en el caso de la gameboy contamos con 160 de ellas (por temas de la resolución de la consola). Pues bien, si interrumpimos a la consola después de pintar cada línea podemos obtener algunos efectos visuales realmente curiosos. En esta pequeña entrada lo que muestro es cómo conseguir una efecto "de ondas" en una imagen que mostramos por pantalla. Para conseguir interrumpir a la consola después de pintar cada línea en pantalla podríamos usar un código como el siguiente:

STAT_REG = 0x08;

disable_interrupts();
add_LCD(LCD_Interrupt);
enable_interrupts();

set_interrupts(LCD_IFLAG);


En la primera línea lo que hacemos es incializar el registro de estado con el valor 0x08 para indicarle a la consola que debe interrumpirse tras pintar cada línea. Posteriormente se deshabilitan todas las interrupciones. Esto es necesario cuando queremos añadir una interrupción nueva para posteriormente volver a habilitarlas. En este caso indicamos que debe invocar a la función LCD_Interrupt() de la cual hablaremos un poco más adelante. Finalmente fijamos el flag LCD para indicar a la Game Boy que queremos interrumpir el LCD de la consola.

Para conseguir el efecto propuesto en esta entrada vamos a desplazar el eje Y de cada "scan line". Para ello creamos un array que indica a cada línea que posición debe tener.

unsigned char effect[] =
{
   0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
   0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
   0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
   0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
   0x05, 0x05, 0x05, 0x05, 0x05, 0x06, 0x06, 0x06, 0x06, 0x06,
   0x07, 0x07, 0x07, 0x07, 0x07, 0x08, 0x08, 0x08, 0x08, 0x08,
   0x09, 0x09, 0x09, 0x09, 0x09, 0x08, 0x08, 0x08, 0x08, 0x08,
   0x07, 0x07, 0x07, 0x07, 0x07, 0x06, 0x06, 0x06, 0x06, 0x06,
   0x05, 0x05, 0x05, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x03,
   0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
   0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01
};


Finalmente definimos la función LCD_Interrupt():

UBYTE counter;

void LCD_Interrupt(void)
{
   SCY_REG = effect[counter];
   counter++;
   if(counter >= 109)
  {
    counter = 0;
  }
}


El efecto de desplazar la posición Y en el LCD lo conseguimos pasando ell valor actual en el arrray "effect" en el registro correspondiente SCY_REG = effect[counter]. Después de esto incrementamos el contador en uno para obtener el siguiente valor del array en la siguiente línea y comprobamos que no nos pasamos del tamaño del array, y en caso de que así sea reseteamos el contador a cero. Y ya está nuestro efecto de ondas conseguido. A continuación pongo el código completo del programa:

#include <gb/gb.h>
#include "batman_3.h"

unsigned char effect[] =
{
   0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
   0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
   0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
   0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
   0x05, 0x05, 0x05, 0x05, 0x05, 0x06, 0x06, 0x06, 0x06, 0x06,
   0x07, 0x07, 0x07, 0x07, 0x07, 0x08, 0x08, 0x08, 0x08, 0x08,
   0x09, 0x09, 0x09, 0x09, 0x09, 0x08, 0x08, 0x08, 0x08, 0x08,
   0x07, 0x07, 0x07, 0x07, 0x07, 0x06, 0x06, 0x06, 0x06, 0x06,
   0x05, 0x05, 0x05, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x03,
   0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
   0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01
};

UBYTE counter;

void LCD_Interrupt(void)
{
   SCY_REG = effect[counter];
   counter++;
   if(counter >= 109)
  {
    counter = 0;
  }
}

void main(void)
{
  HIDE_SPRITES;
  HIDE_BKG;

  counter = 0;
 
  STAT_REG = 8;

  disable_interrupts();
  add_LCD(LCD_Interrupt);
  enable_interrupts();

  //imagen de fondo
  set_bkg_data(0, 0, batman_3_tile_data);
  set_bkg_tiles(0, 0, 20, 18, batman_3_map_data);
 
  set_interrupts(LCD_IFLAG);

  SHOW_BKG;
  SHOW_SPRITES;

   while(1)
   {
      wait_vbl_done();
   }
}


Espero volver dentro de poco con una nueva entrada. Hasta entonces:

Saludos.
Tetris: The Soviet Mind Game

Imagen

Trailer:
https://www.youtube.com/watch?v=DzAnpQb_5G4


Features:

- New Graphics.
- New Sound Effects.
- CGB Type compatibility.
- MBC1 Memory Bank Controller.
- Playable on real hardware.
- Playable with several emulators for all platforms: PC / iOS / Android
o.0 genial, en cuanto llegue a casa le echo un ojo.
El clón de Tetris ya está terminado. Próximamente continuaré con los tutoriales.

Saludos.
Ya queda poco. Estoy editando los últimos videos de tutoriales sobre GB / GBC para pasar a cosas nuevas que casí de seguro postearé por aqui.

Saludos.
Enorme el hilo! Voy a darle un poco de caña a los tutoriales de programación de GameBoy que hacía tiempo que tenía ganas de probar [sonrisa]

PD: veo que lleva un tiempo parado el hilo, espero que no este parada la cosa [mamaaaaa]
helmerpunk escribió:Enorme el hilo! Voy a darle un poco de caña a los tutoriales de programación de GameBoy que hacía tiempo que tenía ganas de probar [sonrisa]

PD: veo que lleva un tiempo parado el hilo, espero que no este parada la cosa [mamaaaaa]


Lleva un tiempo parada, pero más que nada porque voy a dejar hechos todos los tutoriales que faltan hasta el final con sus correspondientes videos, por eso estoy tardando tanto en subir nuevo material. A parte de que ya tengo terminados dos juegos nuevos para GB. Tranquilos que dentro de poco (a la vuelta de vacaciones cómo muy tarde) habrá nuevas entradas en el hilo y nuevo contenido.

Saludos.
Acabo de ver tu vídeo del Raycast Engine para GBA y me ha parecido "amazin" xD
More news soon. Stay tuned.
Tengo una dudilla con el quinto tutorial, el de los efectos de sonidos.

Estoy teniendo problemas a la hora de compilar, me esta dando el siguiente error:
error:_SFX.h: undocumented I/O error

He declarado de esta forma el include:
#include "_SFX.h"

¿Alguien tiene idea que puede estar pasando? ¿A alguien mas le ha pasado?

Un saludo y gracias
A los que usáis GBDK igual os interesa probar esto: https://github.com/rotmoset/gbdk-n

Yo no lo he probado ni lo voy a probar, pero no tiene mala pinta.
Aquí hay un montón de recursos e información, a quién le pueda interesar:
https://github.com/avivace/awesome-gbdev
SefirotDios2 escribió:Tengo una dudilla con el quinto tutorial, el de los efectos de sonidos.

Estoy teniendo problemas a la hora de compilar, me esta dando el siguiente error:
error:_SFX.h: undocumented I/O error

He declarado de esta forma el include:
#include "_SFX.h"

¿Alguien tiene idea que puede estar pasando? ¿A alguien mas le ha pasado?

Un saludo y gracias


_SFX.h es un fichero de cabecera que contiene los datos convertidos de la imagen que se carga cómo background cuando se arranca la rom por primera vez. No lo incluí en el código porque no es representativo de la funcionalidad de la rom. Quita el include y todas las referencias a los arrays _SFX_map_data[] y _SFX_tile_data[] de tu programa para que compile y se genere la rom.

Saludos.

PD: se que me repito mucho, pero... hay nuevo material en camino. Esto no está parado aunque últimamente no actualice mucho el hilo.
Video de la versión Beta del juego HomeBrew para GB - "Tetris: The Soviet Mind Game". El juego ya es completamente jugable pero faltan detalles. Entre ellos los efectos de sonido (que ya están de camino) y la música (que no sé si al final tendrá). Por lo demás la versión actual presenta el modo típico en el que debemos hacer líneas sin parar sin que se acumulen las piezas evitando que toquen el techo. En este caso falta por meter también la puntuación. ¿Echasteis de menos algún modo de juego en el Tetris original de GB que si estuviese en otros juegos de la saga en ARCADE o SNES? Lo pregunto porque dado que tengo otros proyectos en mente, sino es muy difícil de implementar lo puedo meter en este título cómo modo de juego extra. Además también estoy pensando en meter alguna sorpresa en la ROM en caso de alquien lo pruebe en un Super GameBoy. El juego se puede jugar tanto en emuladores cómo en sistema real. El juego está picado integramente en C usando el GBDK.

Trailer:
https://www.youtube.com/watch?v=DzAnpQb_5G4

(Beta-gameplay)
https://www.youtube.com/watch?v=lUUcIghRsts
Pudiera ser que el de Gb tuviera modo A y B? lo digo de memoria porque hace como 20 años que no juego.
Imagen

Volviendo al desarrollo para Gameboy...estoy intentando trasladar lo aprendido para GBA (llevo varios meses haciendo cosillas para GBA y NDS y seguramente más adelante traiga algo de eso por aquqí) a la GB/GBC para hacer un esqueleto de programa que permita a un sprite animado scroll en la pantalla con un fondo. En el video se puede apreciar el proceso de cómo crear el fondo y cómo añadir la lógica de programación para hacer el scroll. NOTA: se me olvido recompilar el fichero .c con los tiles definidos y en el programa final sólo se ven los tiles del background de un único tipo.

https://www.youtube.com/watch?v=sWG2AGZK8eY

Saludos.
Amigo ryoga, he visto que el del emulador m-gba está empezando a dar soporte a GB, quiere hacer un emulador que sea cycle-accurate, puede que os podais ayudar mutuamente
Video en el que muestro cómo crear el engine 2D de un juego básico tipo Snake para GameBoy Advance usando el DevKit-ADV y lenguaje de programación C. Es todo programación a pelo sin usar librerías externas (ya sean menos recientes {tonc} o más recientes {smgbalib}) que facilitan la vida para manejar sprites, backgrounds, sonido, entrada de botones del pad, etc.

Imagen

https://www.youtube.com/watch?v=4-b_JJQzx20

La idea con estos videos es ir subiendo en la dificultad de los juegos hasta llegar a algo más complicado tipo run & gun o beat´em up de cuyos engines llevo trabajando desde hace meses ya sea para GB, GBA o NDS.

Saludos.
He añadido el link de descarga de la ROM. Está en la descripción del video por si a alguien le interesa probar la ROM en un amulador o en hardware real.
Video en el que muestro cómo crear el engine 2D de un juego básico tipo Frontenis para GameBoy Advance usando el DevKit-ADV y lenguaje de programación C. Es todo programación a pelo sin usar librerías externas (ya sean menos recientes {tonc} o más recientes {smgbalib}) que facilitan la vida para manejar sprites, backgrounds, sonido, entrada de botones del pad, etc.

Imagen


Creating a FRONTENIS Game Engine for Game Boy Advance using C Programming Language (DevKitAdv Kit)

La versión avanzada de este juego es el clón de PONG para GBA que ya tengo hecha y que dejaré caer por aquí dentro de poco. De hecho me ha quedado tan bien estructurado que lo puedo aprovechar para hacer una versión con motivo de las elecciones de EEUU. En la descripción del video podréis encontrar el enlace de descarga de la ROM.

Saludos.
Video en el que muestro cómo crear el engine 2D de un juego básico tipo PONG para GameBoy Advance usando el DevKit-ADV y lenguaje de programación C. Es todo programación a pelo sin usar librerías externas (ya sean menos recientes {tonc} o más recientes {smgbalib}) que facilitan la vida para manejar sprites, backgrounds, sonido, entrada de botones del pad, etc.

Imagen

Creating a PONG Game Engine for Game Boy Advance using C Programming Language (DevKitAdv Dev. Kit)

El juego permite seleccionar entre dos jugadores: República Popular China o EEUU. En función de esto los finales que el jugador varían tanto cuando gana cómo cuando pierde. Ahora mismo no recuerdo en cuanto estaba el número de puntos para considerar que un jugador ha ganado la partida (me suenan que eran 30 aunque en el video se ve que son menos).

En la descripción del video he añadido el enlace de descarga de la ROM para que la gente interesada lo pueda probar. Al igual que con otros juegos, la ROM funciona también en hardware real.

Saludos.
Justo estaba en youtube ahora y he visto que has subido el vídeo, luego le echo un ojo.
Video en el que muestro cómo crear el engine 2D de un juego básico tipo TETRIS para GameBoy Advance usando el DevKit-ADV y lenguaje de programación C. Es todo programación a pelo sin usar librerías externas (ya sean menos recientes {tonc} o más recientes {smgbalib}) que facilitan la vida para manejar sprites, backgrounds, sonido, entrada de botones del pad, etc.

Imagen

https://www.youtube.com/watch?v=HeGxAH5ejv4

En la descripción del video he añadido el enlace de descarga de la ROM para que la gente interesada lo pueda probar. Al igual que con otros juegos, la ROM funciona también en hardware real.

Saludos.

PD: el motor beat´em up en el que estoy trabajando para DS/3DS va bastante bien. El año que viene será momento de ir mostrando el desarrollo del juego, aunque antes de eso haré algún video más animando sprites en GBC y GBA.
¿Por qué no usas devkitPro? Teniendo en cuenta que el devkit advance no se actualiza desde 2003 y devkitPro aún tiene actualizaciones de vez en cuando, es bastante tonto usar el devkit advance. Porque lo de no usar librerías lo puedes hacer con devkitPro igual, solo que con un toolchain más moderno.
@SkyLyrac

DevKitPRO lo estoy usando para hacer otros homebrew en DS. En su momento cuando empecé a hacer estos jueguecillos para GBA empecé a usar devkiadv y he seguido con él. ¿porque no cambiar a devkitPRO para desarrollar en GBA? En realidad lo he hecho, sólo que esos ejemplos aún no los he hecho públicos.
Una cosilla.

Veo que en el subforo de consolas clásicas están empezando proliferar los hilos dedicados a la programación en las distintas consolas de 8 y 16 bits. Quizás este hilo tenga su hueco allí, ya que este subforo lo han retirado de los enlaces directos a los subforos.

Un saludo.
tuviello escribió:Una cosilla.

Veo que en el subforo de consolas clásicas están empezando proliferar los hilos dedicados a la programación en las distintas consolas de 8 y 16 bits. Quizás este hilo tenga su hueco allí, ya que este subforo lo han retirado de los enlaces directos a los subforos.

Un saludo.



@tuviello ¿y a quien hay que pedir que se mueva?
Pues, voy a reportar pdidiendo a ver si pueden cambiar el hilo de subforo. Ganarás mucha más visibilidad.
Pues la cosa o está teniendo una deliveración muy compleja o no entiendo lo que pasa. He reportado el hilo para moverlo y abierto un hilo en feedback, pero no he obtenido respuesta alguna: hilo_mover-hilo-de-subforo_2211260

Edit: basta que diga algo para que respondan [ayay]
Gracias a los mods por la mudanza de subforo, a ver si se pasa Ryoga a echar un ojo.
232 respuestas
1, 2, 3, 4, 5