Cómo hacer un juego de GBA

GBAS es la abreviatura de GameBoy Advance development System. Su función principal es transferir juegos y datos de GameBoy Advance. Los usuarios pueden escribir su propio GameBoy Advance. El software se transfiere a la tarjeta de sobrescritura GBAS 64M o GBS 128M. la grabadora GBAS y luego se inserta en el host de GameBoy Advance para su ejecución. Es decir, si también puedes desarrollar juegos de GBA tú mismo (se dice que no es difícil para los buenos programadores), entonces no necesitas la autorización de Nintendo en absoluto y puedes jugar los juegos de GBA que desarrollaste directamente en GBA a través de el sistema GBAS.

Además de transferir el software GameBoy Advance a la tarjeta de sobrescritura, la función de la grabadora GBAS también es capaz de realizar una copia de seguridad del cartucho GameBoy Advance original en la computadora y almacenarlo como un archivo de computadora *.GBA. , o la memoria guardada en cartuchos originales de GameBoy Advance y las tarjetas de sobrescritura GBAS se respaldan como archivos de computadora *.SAV. Estos archivos de copia de seguridad se pueden ejecutar con varios emuladores de computadora GameBoy Advance. Y esto significa que puede usar este sistema para copiar libremente las ROM de juegos GBA en Internet directamente al cartucho GBAS dedicado a través del quemador GBAS. Piense en la cantidad de ROM de juegos GBA que se pueden ejecutar en Internet. ¿Es un poco confuso?

Cabe decir que GBAS es un sistema bastante completo, aunque este sistema acaba de ser desarrollado, ya es bastante excelente en cuanto a funciones.

1. Compatibilidad con memoria especial EEPROM: este GBAS es actualmente la única herramienta de desarrollo GBA que admite el formato de memoria EEPROM, y también es la única herramienta de desarrollo que actualmente admite Super Mario Advance (Japón/EE. UU.). Jaja, debes saber que la versión americana de Super MARIO Adventure aún no ha sido lanzada, y en Internet la ROM de este juego ya está disponible desde hace mucho tiempo, por lo que puedes ver que el juego GBA ejecutado en la imagen es la versión americana. de Súper MARIO Aventura.

2. Memoria de batería súper grande: la memoria de batería súper grande de 1 M admite todas las memorias del juego (incluida la memoria de batería súper grande de la quinta generación de Yu-Gi-Oh!). Esta característica es bastante buena y se acerca más a las características de los jugadores. En términos generales, al usar esto, no habrá problemas con la grabación de ningún juego. No hay necesidad de que los jugadores se preocupen por la falta de espacio en la memoria del GBAS.

3. Función de combinación de tarjetas: GBAS admite combinación de tarjetas y la versión de 64 M puede admitir dos tarjetas de juego de 32 M. De esta manera, los jugadores pueden grabar dos juegos de 32M a la vez, haciendo de GBAS una tarjeta combinada. Si el jugador tiene una tarjeta de sobrescritura de 128M, entonces puede convertir su GBAS en una tarjeta 4 en 1, lo que, por supuesto, ahorra dinero. , el tiempo que lleva grabar y copiar el juego es mucho mayor para una tarjeta de 128M.

4. Interfaz de operación: la interfaz de grabación en la nueva ventana (incluidas las funciones de carga y descarga de juegos y carga y descarga de archivos de registro de juegos) ha corregido recientemente el problema de transmisión del juego, es más rápida y precisa, y es compatible. La plataforma operativa Windows 9X es fácil de instalar y usar, por lo que los usuarios no tienen que preocuparse de que algo salga mal.

Sistema de producción y grabación de software de GBA: GBAS

Introducción simple-

1 Introducción al kit de desarrollo de GBA: DevKitAdv

DevKitAdv Incluye principalmente dos partes, una es el compilador GCC y la otra es la biblioteca GBA.

La función del compilador GCC es similar a la de nuestro VC de uso común, excepto que carece de un editor de texto. para editar el código fuente (al menos no tengo uno) descubrí que uso EditPlus, también se puede usar UltraEdit) y no hay soporte para clases (clase), lo cual es realmente un dolor de cabeza, así que solo puedo usar struct en su lugar, su función es compilar el código que escribimos en un archivo ejecutable binario. Por supuesto, este archivo ejecutable es relativo a GBA y al emulador GBA. Al igual que los archivos EXE en Windows no se pueden usar en Mac;

La biblioteca GBA proporciona imágenes, una serie de funciones de control y sonido, utilizadas junto con GCC.

Dirección de descarga: mand)

3.

/ / main.c

// Algunos tipos de datos básicos

typedef unsigned char u8;

typedef unsigned short u16;

typedef unsigned long u32;

#define REG_DISPCNT *(u16*)0x04000000 // Mostrar dirección de registro

#define VRAM 0x06000000 // Dirección de búfer de imagen

#define M5_VRAM 0x0600A000 // Dirección del buffer M5

#define BACKBUFFER 0x010 // Dirección del buffer doble/back buffer

#define PALETTE 0x5000000 // Dirección de la paleta

#define MODE_3 0x03 // 240*160 15 bits/búfer único

#define MODE_4 0x04 // 240*160 8 bits/búfer doble

#define MODE_5 0x05 / / 160 *128 15bits/doble buffer

#define BG2_ENABLE 0x0400 // BG_2

#define SetMode(Mode) REG_DISPCNT=(Mode) // Definición de macro para configurar el modo de visualización

// ----------- Programa principal------------

int main()

{

//Establezca el modo de pantalla, aquí se usa MODE_4

SetMode (MODE_4 | BG2_ENABLE

}

1. MODE_5 y MODE_3 Ambos son de 16 bits, pero MODE_3 solo tiene un búfer único y el efecto de animación definitivamente no es tan bueno como el búfer doble, por lo que MODE_3 está excluido;

2.MODE_4 es de 8 bits en teoría, 256 colores. son suficientes para una máquina portátil, aunque 16 bits en realidad nadie quiere resistir la tentación del color, pero MODE_5 es solo 160*128. En aplicaciones prácticas, se recomienda utilizar MODE_4.

Es muy. simple: de hecho lo es, ahora necesitas usar GCC para compilarlo:

p>

gcc -lm -o main.elf main.c

objcopy -v -O binario principal.e

lf main.bin

Verás un "main.bin" adicional en el directorio. ¡Este es un archivo binario que se puede ejecutar en el emulador GBA!

t1-t10 en. el tutorial El directorio es el directorio del programa fuente y contiene make.bat. Después de modificar el código, ejecútelo directamente para compilar, pero tenga en cuenta que mi devkitadv está instalado en D :. tendrás que cambiar el parámetro de ruta make.bat.

IV. Programa GBA (t2) para dibujar imágenes en la capa de fondo MODE_4

Dibujar una imagen en MODE_4 de GBA requiere tres pasos. :

1. Convierta el archivo de imagen original de 256 colores en un archivo de datos *.h / *.c. Usamos lt; Después de la conversión, obtenemos un archivo "image.h";

2. #incluye "image.h" al comienzo del programa, de modo que la paleta y los datos de imagen definidos por "image.h" se puede utilizar en el programa;

3. En el programa, escriba la paleta y los datos de imagen definidos por "image.h" en la paleta y el búfer de imagen de la capa de fondo MODE_4.

Además, GBA también La capa de objeto especialmente configurada para sprites tiene el mismo uso que la capa de fondo, pero la función es un poco diferente. La dirección es 0x06000000. No entraré en detalles sobre su uso aquí. Puede enviar directamente los datos del sprite al búfer del objeto

El siguiente es el programa fuente:

... ...

//Archivo de encabezado. que contiene paleta de imágenes y datos

#include "gfx/image.h"

// ----------- Variables globales------- -

// Paleta del sistema

u16* paleta_mem=(u16*)PALETTE;

//Búfer de imagen

u16* video_buffer =(u16*)VRAM;

// ----------- Definición de función---------

// Función de dibujo MODE_4

void Draw(u16* src_palette, u16* src_data, u16* dst_palette, u16* dst_data);

// ---------- Programa principal -- -------- ---

int main()

{

//Establece el modo de pantalla, aquí usa MODE_4

SetMode (MODE_4 | BG2_ENABLE);

//Dibujando en la capa de fondo, Paleta y Datos son los nombres de la matriz de datos de imagen y paleta definidos en "image.h"

Dibujar(Paleta, Datos, paleta_mem, video_buffer);

}

// Función de dibujo MODE_4

void Draw(u16* src_palette, u16* src_data, u16* dst_palette, u16* dst_data)

{

int loop, x, y;

//Escribe la paleta de destino

for(loop = 0; loop lt; 256; loop )

dst_palette[loop] = src_palette[loop];

//Escribir en el búfer de imágenes

>

for(x = 0; x lt; 120; x)

{

for(y = 0; y lt; 160; y)

{

dst_data[(y) *120 (x)]=src_data[(y) *120 (x)];

}

}

}

Después de compilar, obtenga main.bin y luego ejecútelo en el emulador GBA, puede obtener el resultado como este:

5. en el programa MODE_5 GBA (t3)

Dibujar una imagen en MODE_5 de GBA también requiere tres pasos similares, excepto que no se requieren datos de paleta:

1. Archivos de datos .h / *.c, usamos lt; Targa2GBA gt;, aquí tomamos "image.bmp" (240*160) como ejemplo. Vaya al directorio Targa2GBA en la ventana de DOS e ingrese "imagen t2g mode5. bmp image.h", después de la conversión obtendremos un archivo "image.h";

2. #incluye "image.h" al principio del programa, para que pueda incluirse en el programa Utilice los datos de imagen definidos por "image.h";

3 Escriba los datos de imagen definidos por "image.h" en el búfer de imágenes del programa.

Lo siguiente es el programa fuente:

//Archivo de encabezado que contiene datos de imagen

#include "gfx/image.h"

// ------ --- -- Variables globales--------

//Búfer de imagen

u16* video_buffer=(u16*)VRAM;

// ----------- Definición de función---------

// función de dibujo MODE_5

void Draw(int x, int y, int w, int h, u16 *src_data, u16 *dst_data);

// ---------- Programa principal------------

int main()

{

// Establece el modo de pantalla, aquí se usa MODE_5

SetMode (MODE_5 | BG2_ENABLE) ;

// Dibuja en la capa de fondo, la imagen es el nombre de la matriz de datos de la imagen definida en "image.h"

Draw(0, 0, 240, 160, image , video_buffer);

}

// Función de dibujo MODE_5

void Draw(int x, int y, int w, int h, u16 * src_data, u16 *dst_data)

{

int i, o, idst;

// Copia los datos de la imagen de origen en el lugar especificado en el búfer de imágenes.

idst = (y*160) x;

for (i=0; ilt; h; i )

{

for (o=0; olt; w ;o )

{

if (*src_data != 0)

{

dst_data[idst] = *src_data;

}

idst

src_data

}

p>

idst = (160-w);

}

}

Resultados compilados y en ejecución:

6. Programa GBA MODE_5 de pantalla completa (t4)

Dado que GBA no admite la transformación de imágenes lineales, los resultados obtenidos producirán algunos fenómenos de mosaico. Ahora todavía adjunto la función de transformación y el resultado final. la calidad sigue siendo la misma. Es aceptable, puedes intentar usar este nuevo MODE_5.

// Cambia al nuevo modo de pantalla completa MODE_5, la página es el búfer, el principio es intercambiar la visualización. registre los datos X e Y para obtener una visualización de 128*160, GBA se mostrará en pantalla completa.

void SetFlipMode(int page)

{

u16 *ioreg =(u16*)0x4000000;

*ioreg=5 ((pageamp;1)gt;gt;4) (1gt;gt;10);

ioreg[0x10]= 0;

ioreg [0x11]=256;

ioreg[0x12]=128;

ioreg[0x13]=0;

}

int main()

{

//Establece el modo de pantalla, aquí se usa MODE_5

SetMode (MODE_5 | BG2_ENABLE);

// Cambiar modo

SetFlipMode(0);

// Dibujar en la capa de fondo, la imagen es el nombre de la matriz de datos de la imagen definido en "image.h"

Draw (0, 0, 240, 160, image, video_buffer);

r7. Visualización de doble buffer de GBA (t5)

Definitivamente lo descubrirás al realizar el programa MODEL_5 anterior. La imagen parpadea (la imagen de 240*160 MM en la Sección 6 está desenfocada...), pero es relativamente estable en MODEL_4; esto se debe a que MODEL_5 tiene que procesar 16 bits. (esencialmente 15 bits) imágenes y datos. La cantidad es mucho mayor que los 8 bits en MODEL_4. Si no se utiliza el almacenamiento en búfer doble, se producirá parpadeo cuando se llene la imagen. Es por eso que abandonamos MODEL_3...