Red de conocimiento informático - Material del sitio web - Cómo hacer un juego de GBA

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;

p>

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) ;

p>

// 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);

p>

}

// 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...

El principio también es muy simple. Una vez que la imagen se completa en el búfer posterior, se envía directamente al búfer frontal para su visualización. El programa es un proceso de "espera de sincronización-gt; intercambio de búfer":

... ...

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

// Búfer de imagen

u16* video_buffer= (u16*)M5_VRAM;

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

... ...

//Esperando la sincronización de datos del búfer

void WaitSync ();

//Intercambiando contenido del búfer

void SwapScreen () ;

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

int main()

{

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

SetMode (MODE_5 | BG2_ENABLE);

while(1)

{

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

dra

w(0, 0, 240, 160, imagen, video_buffer);

WaitSync();

SwapScreen()

}

<; p>}

//Esperando la sincronización de datos del búfer

void WaitSync ()

{

mientras (*(volatile u16* )0x4000006lt; 160) {};

}

// Intercambiar buffer

void SwapScreen ()

{

if (REG_DISPCNT & BACKBUFFER)

{

REG_DISPCNT & BACKBUFFER;

video_buffer = (u16*) M5_VRAM;

p>

}

else

{

REG_DISPCNT |= BACKBUFFER;

video_buffer = (u16*) VRAM;

}

}

8. Entrada de clave GBA (t6)

Hablé de los gráficos durante mucho tiempo, aunque fue para MM, pero todos deben estar un poco molestos. Cambiemos la dirección ahora y echemos un vistazo al control GBA.

... ...

// Control de botones

.

#definir KEY_A 1

#definir KEY_B 2

#definir KEY_SELECT 4

#definir KEY_START 8

#definir KEY_RIGHT 16

#define KEY_LEFT 32

#define KEY_UP 64

#define KEY_DOWN 128

#define KEY_R 256

#define KEY_L 512

volatile u32* KEYS = (volatile u32*)0x04000130;

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

#include "gfx/image.h"

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

// Búfer de imagen

u16* video_buffer=(u16*)M5_VRAM;

//Coordenadas de visualización de la imagen

int img_x, img_y;

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

// Control de clave

void KeyAction();

... ...

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

int main( )

{

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

SetMode (MODE_5 | BG2_ENABLE);

while( 1)

{

// Manejar eventos clave

KeyAction();

// Dibuja imágenes en la capa de fondo, imagen ¿El nombre de la matriz de datos de la imagen está definido en "image.h"?

Draw(img_x, i

mg_y, 96, 64, imagen, video_buffer);

WaitSync();

SwapScreen()

}

}<; /p>

// Manejar eventos clave

void KeyAction()

{

// Tecla de flecha hacia arriba

if (! ( (*KEYS) amp; KEY_UP) )

{

img_y =5;

}

// Dirección hacia abajo Clave

if(! ( (*KEYS) amp; KEY_DOWN) )

{

img_y-=5;

}

}

eturn(0);

9. Salida de sonido simple (t7)

Lo simple es lo mejor. Aquí usamos un módulo de sonido listo para usar (Troff Player, de Vova amp; Serge). Aquí también utilizamos una herramienta de conversión lt; MOD2GBA gt;, que se utiliza para convertir archivos de música MOD en archivos de datos de sonido GBA *.c / *.h. similar a MIDI, pero admite más efectos y más potentes. El MOD se puede convertir mediante konvertor, un potente software.

// Archivo de datos MOD

# incluye "song_data.h"

// Archivo de función de reproducción MOD

#include "modplayer.h"

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

int main()

{

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

SetMode (MODE_4 | BG2_ENABLE);

//Inicializa el sonido (número de canales, volumen)

InitSound(2, 7);

p >

//Inicializar música (tiempo, bucle)

InitSong(20000, 0);

while(1)

{

//Actualizar el estado de reproducción de música

UpdateSong();

}

}

OK, eso es todo EZ <. /p>

10. Utilice mosaicos para crear un fondo desplazable/con zoom/giratorio (t8)

Esta sección trata principalmente sobre comentarios en el programa fuente, por lo que no la explicaré en detalle aquí. "gba.h" contiene definiciones de macros básicas, "maths.h" es la matriz de valores de sin/cos multiplicada por 256 y "main.h" incluye funciones para que podamos definir la estructura del fondo y operar el fondo.

El fondo del mapa en el programa se compone de diferentes mosaicos, y estos mosaicos se colocan uno al lado del otro en un archivo de imagen, de modo que cada mosaico tendrá un número de índice en el que solo es necesario registrar la información del mapa; este mapa** *Cuántas unidades (mosaicos) hay y el número de índice del mosaico correspondiente a cada unidad está bien. En el ejemplo, "gfx/tiles.h" es el campamento base del mosaico y "gfx/level1.h" es. la tabla de clasificación del índice de mosaicos. La herramienta de mapas es "editor de mapas beta 4".

El desplazamiento/zoom/rotación del fondo se completa mediante una serie de cálculos matemáticos simples y la modificación de algunas propiedades del fondo proporcionadas por el. Sistema GBA, porque es La operación en segundo plano se completa mediante hardware (MODE_1), por lo que la velocidad es muy rápida. También tengo una rutina que modifica directamente la posición del píxel para completar la rotación en MODE_5. p>