ZGB

ZGB est un moteur Game Boy / Game Boy Color qui vous permet d'écrire vos propres jeux en C ou Asm.

Il utiliseGBDK 2020mais l'étend pour vous donner une certaine fonctionnalité commune pour écrire des jeux tels que: une boucle principale, sprites frai, sprites cycle de vie, sprites animations, gestion de collison, facilement obtenir des actifs dans le jeu, musique, fx...

Début

• Installation de ZGB
  • Télécharger la dernièrerelease
  • Exécuter install.bat (ceci créera un nouvel environnement var ZGB PATH pointant vers %ZGB%/common)

REMARQUE: assurez-vous que le chemin ZGB ne contient aucun espace (plus d'infoshere)

• Création d'un nouveau projet
  • Téléchargez leZGB-templateet de le construire en courant build.bat
  • Suivez le tutoriel sur lewikicomprendre les concepts de base du moteur
• (Facultatif) TéléchargerMicrosoft Visual Studio Community EditionLesZGB-templatelivré avec une solution personnalisée pour studio visuel

Documentation

Vérifiezwikiet ce README

Appui

• twitter:Zal0
• discorde:gbdk/zgb discord

Caractéristiques

(Cliquez sur n'importe quelle fonctionnalité pour l'agrandir)

Dans la plupart des cas, vous avez juste besoin d'un petit makefile comme ceci

PROJECT_NAME = ZGB_TEMPLATE

all: build_gb

# Number of banks (must be a power of 2): A (Automatic), 2, 4, 8, 16, 32...
N_BANKS = A

# Music player: HUGETRACKER(default) or GBT_PLAYER
MUSIC_PLAYER = GBT_PLAYER

# Default hardware sprites size: SPRITES_8x16(default) or SPRITES_8x8
DEFAULT_SPRITES_SIZE = SPRITES_8x16

include $(ZGB_PATH)/src/MakefileCommon

Lorsque vous apportez des modifications aux fichiers sources de votre projet, ou à l'un des actifs, seul ce fichier sera recompilé. Le Makefile interne qui vient avec ZGB crée une liste de dépendances et ne compile que ce qui est nécessaire pour vous sauver beaucoup de temps. Il vous aidera également beaucoup si vous travaillez avec un système de contrôle de version, comme git

ZGB transformera automatiquement tous vos fichiers d'actifs en données C :

• Graphiques
  • .gbr de Game Boy Tile Designer
  • .gbm de Game Boy Map Builder
  • .png que peut être utilisé pour les fonds ou les sprites
• Musiques
  • .mod pour lecteur gbt
  • .uge pour hUGETracker

Pour utiliser l'une quelconque de ces données dans votre code, vous devez d'abord la déclarer en utilisant

IMPORT_MAP(<map_filename_without_extension>)
IMPORT_TILES(<map_filename_without_extension>)
DECLARE_MUSIC(<map_filename_without_extension>)

Tous les jeux ZGB doivent contenir au moins un État. Cet état doit être attribué sur ZGBMain.c

UINT8 next_state = StateGame;

Quand ZGB commence il appellera leDÉPÔTfonction de cet État. Ensuite, sur chaque cadre il appellera leMISE À JOURfonction jusqu'àÉtat définiest appelé à attribuer un nouvel État

Création d'un nouvel État

1. Créer un nouveau fichier < YourNewState >.c contenant ceci :

#include "Banks/SetAutoBank.h"

void START() {
}

void UPDATE() {
}

1. Enregistrer ce nouvel Etat dans ZGBMain.h

#define STATES             \
...
_STATE(<YourNewState>)       \
STATE_DEF_END

Maintenant, chaque fois que vous voulez entrer dans ce nouvel état, vous devez juste appelerÉtat défini(< Votre nouvel État >)

Vous pouvez ajouter manuellement Sprites appelantAdditif(type, x, y). ZGB va appeler leDÉPÔTfonction de ce Sprite d'abord et puis il appelleraMISE À JOURsur chaque cadre jusqu'à ce que la Sprite soit enlevée. Vous pouvez supprimer manuellement un Sprite avec la fonctionSpriteManagerSupprimerouSpriteManagerSupprimerSpritepuis le moteur appelleraDESTROYfonction.

Les sprites seront également supprimés lors de la sortie des limites de l'écran. Vous pouvez configurer la distance que vous leur permettez d'aller avant que le moteur les dispose avec les champslim xetlim y

Habituellement, vous allez créer un Sprite dans la fonction START de votre État et l'assigner à défiler cible, de sorte que la caméra le suit

void START() {
	scroll_target = SpriteManagerAdd(SpritePlayer, 50, 50);
	...
}

Vous pouvez créer vos sprites avec le Game Boy Tile Designer ou vous pouvez utiliser pngs. Créez vos sprites dans le dossier res/sprites afin que le Makefile puisse les identifier comme des sprites et passer les paramètres appropriés à png2asset.

gbr sprites Utilisez Game Boy Tile Designer inclus dans /env/tools/gbtd22/GBTD.exe pour créer des sprites gbr. Ne vous inquiétez pas trop du TileSize choisi, rappelez-vous que les carreaux vides seront jetés

La première fois que vous compilez le gbr a.meta sera créée avec les paramètres par défaut passés à png2asset. Vous voudrez peut-être jeter un coup d'oeil à l'information de collision pour ajuster le collider

-px 0 -py 0 -pw 32 -ph 32

Vérifiez les paramètres png2assethere

png sprites

GBTD a quelques limites:

• La taille maximale des sprites est 32x32
• Il vous permet seulement de choisir une palette pour toute la metasprite

Heureusement, vous pouvez surmonter ces limitations en utilisant votre logiciel d'art pixel préféré, puis exporter vos données comme une feuille sprite

Comme avec gbr sprites un fichier .meta peut être créé pour passer des arguments à png2asset. Contrairement à gbr sprites ce fichier .meta ne sera pas créé automatiquement donc il est important que vous le créiez et au moins indiquez les dimensions du sprite (ou il sera exporté comme un seul sprite)

-sw 32 -sh 16 

Vérifiez les paramètres png2assethere

Créer un nouveau Sprite

Le modèle est déjà livré avec un Sprite placeholder, mais vous devrez certainement ajouter plus. Faites ceci en suivant les 3 prochaines étapes:

1. Créez les données d'image sprite.
2. Créer un nouveau fichier < YourNewSprite >.c contenant ceci :

#include "Banks/SetAutoBank.h"

void START() {
}

void UPDATE() {
}

void DESTROY() {
}

1. Enregistrer cette nouvelle Sprite dans ZGBMain.h

#define SPRITES \
...
_SPRITE_DMG(<YourNewSprite>, <image>)\
SPRITE_DEF_END

ZGB supporte des cartes jusqu'à 16384 octets avec une largeur ou une hauteur maximale de 255 tuiles. Le moteur s'occupera de mettre à jour l'arrière-plan natif 32x32 à mesure que la caméra se déplace

Voici comment vous créez une nouvelle carte et la chargez dans votre jeu:

• Ouvrir le jeu Boy Tile Designer inclus dans <ZGB PATH>/env/tools/gbtd22 et créer un nouvel ensemble de tuiles
• Ouvrir Game Boy Map Builder inclus dans <ZGB PATH>/env/tools/gbmb18 et créer une nouvelle carte qui utilise le jeu de tuiles précédent
• Dans la fonction START de votre état, vous devez ajouter manuellement le sprite que la caméra suivra
• Importez votre carte et appelez InitScroll

IMPORT_MAP(map); //This is the name of your map without the extension

void START() {
	scroll_target = SpriteManagerAdd(SpritePlayer, 50, 50);
	InitScroll(BANK(map), &map, 0, 0);
}

Comme le défilement met à jour de nouvelles lignes ou colonnes, il appellera la fonction GetTileReplacement située dans ZGBMain.c Le comportement par défaut de cette fonction est de créer des sprites en utilisant sprite tye = 255 - carle id, mais vous pouvez le personnaliser pour vos besoins personnalisés

Les métasprites sont des sprites composés de sprites natifs 8x8 ou 8x16. L'outil png2asset de GBDK est utilisé pour créer les données qui finiront dans la construction finale:

• les carreaux dupliqués ne seront ajoutés qu'une seule fois
• les carreaux miroirs seront également comptés comme dupliqués
• les carreaux vides seront ignorés
• palette info sera inclus

Le Game Boy a un support natif pour les tailles de sprite 8x8 et 8x16. Vous pouvez utiliser n'importe lequel d'entre eux pour composer les metasprites dans votre jeu.

Choisir la taille 8x8 facilitera la duplication de parties de la metasprite et nécessitera moins de mémoire pour le stocker mais prendra plus de temps pour rendre la metasprite finale

Le mode Sprite par défaut est sélectionné dans votre makefile

# Default hardware sprites size: SPRITES_8x16(default) or SPRITES_8x8
DEFAULT_SPRITES_SIZE = SPRITES_8x16

Les animations en ZGB sont définies par des tableaux de cadres où le premier élément est le nombre de cadres

const UINT8 anim_walk[] = {4, 0, 1, 2, 1, 0};

Réglage de l'animation actuelle est fait avecSetSpriteAnim(sprite, animation, vitesse)

Au lieu de définir une animation, vous pouvez définir le cadre actuel manuellement en appelantSetFrame(Sprite, frame idx)

Le champ Spriteanim framecontient l'index d'animation s'il y a une animation en cours, ou l'index d'image autrement

Tous les sprites ont un collider rectangle qui sera utilisé pour vérifier les collisions. Par défaut, il sera défini par les dimensions de metasprites mais vous pouvez l'ajuster sur le fichier sprite .meta

-px 2 -py 0 -pw 12 -ph 19

Ce rectangle restera constant lorsque le sprite sera retourné

D'abord, vous devez déclarer un tableau (terminé en 0) indiquant quelles tuiles sont considérées comme des collisions

UINT8 collision_tiles[] = {1, 2, 3, 4, 8, 10, 0}; //In this case tiles 1, 2, 3, 4, 8 an 10 will be considered collidables

Ensuite, vous devez passer ce tableau lorsque vous Initez le défilement (vous pouvez avoir plusieurs tableaux selon le jeu de carreaux que vous utilisez)

InitScroll(BANK(map), &map, collision_tiles, 0);

Et maintenant, au lieu de modifier directement les coordonnées X et Y de votre Sprite, vous devez appeler TranslateSprite

TranslateSprite(THIS, -1, 0); //Move the current sprite 1 pixel to the left checking collisions with the background

Si le Sprite se heurte alors il n'avance pas et TranslateSprite retournera la tuile de collision (pour que vous puissiez vérifier s'il y a des pics ou d'autres choses)

Vous pouvez également déclarer un tableau de tuiles de collision qui ne sera vérifié que lorsque le Sprite se déplace vers le bas. Ceci est très utile pour les jeux de plate-forme où le personnage peut sauter dans une plate-forme d'en bas

Pour vérifier si deux sprites entrent en collision, appelez la fonction CheckCollision dans "Sprite.h"

if(CheckCollision(THIS, other_sprite))
{
    //Sprites are colliding!
}

Utilisations du ZGBbankpackdonc vous n'avez pas besoin de vous soucier de l'endroit où placer votre code ou vos ressources. Assurez-vous que :

• #incluez "Banques/SetAutoBank.h"est ajouté au début de vos États et Sprites
• Si vous devez appeler une fonction sprite d'un autre sprite, déclarez-laBANQUES

void HitMe();        //WRONG!!
void HitMe() BANKED; //RIGHT!

• Vérifiez le png créé dans le dossier Debug/Release de votre compilation pour obtenir un aperçu de l'utilisation de vos banques. Pour plus d'informations, vous pouvez utiliserRomUsage

Les polices dans ZGB sont des fichiers gbr de45tuiles, avec caractères majusculesA-Z 0-9 !'()-.:?Le ZGB-Template est déjà livré avec une police par défaut que vous pouvez personnaliser

Pour imprimer des textes dans votre jeu

1. Importer la police en utilisant

#include "Print.h"
IMPORT_TILES(<font filename>);

1. Initez la police dans la fonction START de votre État en appelant

INIT_FONT(font, PRINT_BKG); //PRINT_BKG to draw on the background or PRINT_WIN to draw on the Window

1. Imprimer un texte en utilisant

PRINT(0, 0, "Hello World"); //print Hello World on 0, 0

Vous pouvez également utiliserImprimerfpour dessiner quelques vars avec %d %i &u et %s

Vous pouvez changer la cible (arrière-plan ou fenêtre) avec la varcible d'impression

Vous pouvez sélectionner le lecteur de musique de sorcière à utilisergbt-playerouhUGETrackerdans le fichier Makefile

# Music player: HUGETRACKER(default) or GBT_PLAYER
MUSIC_PLAYER = GBT_PLAYER

Pour jouer de la musique dans votre jeu

• Placez les fichiers .mod ou .uge dans le dossier res/music
• Importer la musique avec

DECLARE_MUSIC(<music_filename>)

• Jouez avec

PlayMusic(<music_filename>, LOOP)

• Et arrête avec

StopMusic;

Pour jouer un son FX, il suffit d'appeler

void PlayFx(SOUND_CHANNEL channel, UINT8 mute_frames, ...); // Add register data from GBSound

La chaîne sera occupée pendant les mute frames et le lecteur de musique ne pourra pas l'utiliser

Comme ZGB utilise png2asset, les données de la palette seront toujours incluses pour chaque sprite permettant à ZGB de charger automatiquement la palette lorsque le Sprite est chargé

Assurez-vous que :

• Le total des sprites chargés n'a pas besoin de plus de 8 palettes différentes (si deux sprites ont les mêmes palettes, ils les partageront)
• Les couleurs de la palette sont commandées de plus léger à plus sombre de sorte que le jeu sera également bon sur le GB original

Suivez les prochaines étapes pour créer Super Game Boy bordures pour votre jeu

• créer le dossier res/borders
• Ajouter un png avec ces limitations:
  • taille doit être 256x224
  • il doit y avoir un rectangle transparent 160x144 au centre
  • nombre maximum de tuiles différentes est 256
  • chaque carrelage 8x8 a une limite de 16 couleurs
  • il ne peut y avoir que 4 palettes différentes de 16 couleurs
  • voici unetemplatevous pouvez utiliser
• Dans votre code (faire cela avant de charger toute autre carte bg)

#include "SGB.h"

IMPORT_MAP(<border_filename>);

void START() {
  LOAD_SGB_BORDER(<border_filename>);
  ...
}

Afin d'avoir des savegames dans votre jeu, vous devez inclure quelques fichiers appelés savegame.h et savegame.c avec le contenu suivant

//savegame.h
#ifndef SAVEGAME_H
#define SAVEGAME_H

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

typedef struct {
	SAVEGAME_HEADER;

  //Whatever content you want to store in external ram

} Savegame;

extern Savegame savegame;

#endif

//savegame.c
#include "savegame.h"
Savegame savegame;

Avoir un fichier nommé savegame.c dans votre projet le compilera automatiquement en utilisant MBC1+RAM+BATTERY (autrement il utilisera MBC1)

Ensuite, avant d'accéder à tout contenu, vous devez activer/désactiver l'accès à sram

ENABLE_RAM;
  //Acess savegame content to read/write
DISABLE_RAM;

LesZGB-templateest correctement configuré pour le débogage C sousEmuliciousdansVisual Studio Code. Si vous avez commencé votre projet actuel avec une ancienne version du modèle, vous devez simplement copier le dossier .vscode dans la racine de votre projet.

• DownloadCode Studio visuel
• Ouvrez l'espace de travail situé dans le dossier .vscode dans le modèle ZGB
• Installez les extensions recommandées dans l'espace de travail :
  • C/C++ for Visual Studio Code
  • Emulicious Debugger

Assurez-vous maintenant que vous avez soit Debug ou DebugColor sélectionné comme votre configuration actuelle et appuyez sur F5 pour commencer le débogage. Emulicious sera lancé automatiquement et les points d'arrêt seront touchés. Bon appétit !

Licence

Libéré sous le régimeMIT license

Contributeurs GitHub

bbbbbr

1084 contributions

Zal0

163 contributions

sergeeo

29 contributions

josemwarrior

2 contributions

Aljenci

1 contributions

Calindro

1 contributions

ZaloAxes

1 contributions

jellelicht

1 contributions

joyrider3774

1 contributions

untoxa

935 contributions