• 20 heures
  • Difficile

Mis à jour le 05/12/2013

La base

Connectez-vous ou inscrivez-vous gratuitement pour bénéficier de toutes les fonctionnalités de ce cours !

Voici la première partie liée à de la programmation pure et dure. Ouvrez grand vos yeux ! La partie de plaisir peut enfin commencer.
Je fournirai le code pour presque toutes les actions à effectuer, mais il est inutile de préciser qu'il vaut mieux comprendre et écrire son propre code que d'effectuer des copier-coller.
Let's gooo!

L'implémentation de la machine

Nous allons commencer par récupérer une citation dans la description de la Chip 8, que nous nous contenterons de traduire en langage machine.
Cette partie concernera le CPU de la Chip 8. Le CPU est l'organe central de notre émulateur : c'est le chef d'orchestre.
Are you ready?

La mémoire

Citation

Les adresses mémoire de la Chip 8 vont de $200 à $FFF (l'hexadécimal revient), faisant ainsi 3 584 octets. La raison pour laquelle la mémoire commence à partir de $200 est que sur le VIP et Cosmac Telmac 1800, les 512 premiers octets sont réservés pour l'interpréteur. Sur ces machines, les 256 octets les plus élevés ($F00-$FFF sur une machine 4K) ont été réservés pour le rafraîchissement de l'écran, et les 96 octets inférieurs ($EA0-$EFF) ont été réservés pour la pile d'appels, à usage interne, et les variables.

Bien que cette citation soit assez longue, ce qui nous intéresse est : « Les adresses mémoire vont de $200 à $FFF, faisant ainsi 3 584 octets » et « les 512 premiers octets sont réservés ». Je rappelle que $200 = 512.
On peut déduire de ces deux informations que la Chip 8 a une mémoire de 3 584 + 512 = 4 096 octets (un octet = huit bits, ne l'oubliez jamais). Le reste n'est que culture générale.
Et comme nous allons simuler le fonctionnement de notre machine, le rafraîchissement sera géré par une autre méthode. Il existe des fonctions dédiées pour toutes les bibliothèques graphiques (update, repaint, SDL_Flip, etc). Les 512 premiers octets ne serviront donc à rien (pour le moment).

Dans mon cas, la variable mémoire prendra la forme d'un tableau de 4 096octets.

Je parle en connaissance de cause. :honte:

Donc, à nous les unsigned dans tous les sens ! Pour ma part, j'utilise SDL, donc à moi les Uint.

Déclaration de la mémoire :

Uint8 memoire[4096]; // la mémoire est en octets (8 bits), soit un tableau de 4096 Uint8.

Maintenant, pour pointer sur une adresse donnée, il faut une autre variable qui sera initialisée à $200 = 512 comme nous le dit la description.
Nous la nommerons pc comme « program counter ». La variable doit être de 16 bits au minimum car nous devons être en mesure de parcourir tout le tableau mémoire qui va de 0 à 4095.

Les registres

Citation

La Chip 8 comporte 16 registres de 8 bits dont les noms vont de V0 à VF (F = 15, encore l'hexadécimal). Le registre VF est utilisé pour toutes les retenues lors des calculs.
En plus de ces 16 registres, nous avons le registre d'adresse, nommé I, qui est de 16 bits et qui est utilisé avec plusieurs opcodes qui impliquent des opérations de mémoire.

Ici, il n'y a rien de compliqué, nous nous contenterons donc juste de déclarer les variables. Les registres permettent à la Chip 8 − et à tout processeur en général − de manipuler les données. Ils servent en gros d'intermédiaires entre la mémoire et l'unité de calcul, ou l'UAL (Unité Arithmétique et Logique) pour les intimes. Le processeur gagne en vitesse d'exécution en manipulant les registres au lieu de modifier directement la mémoire.

La pile ou stack

Citation

La pile sert uniquement à stocker des adresses de retour lorsque les sous-programmes sont appelés. Les implémentations modernes doivent normalement avoir au moins 16 niveaux.

Lorsque le programme chargé dans la mémoire s'exécute, il se peut qu'il fasse des sauts d'une adresse mémoire à une autre.
Pour revenir de ces sauts, il faut sauvegarder l'adresse où il se trouvait avant ce saut (pc) : c'est le rôle de la pile, appelée stack en anglais. Elle autorise seize niveaux, il nous faudra donc un tableau de seize variables pour stocker les seize dernières valeurs de pc ; on le nommera saut.
Et comme pour la mémoire, on aura besoin d'une autre variable afin de parcourir ce tableau. Cette fois-ci, le type Uint8 fera l'affaire puisqu'on ne parcourt que seize valeurs. Je l'ai nommée nbrsaut.

Les compteurs

Citation

La Chip 8 est composée deux compteurs. Ils décomptent tous les deux à 60 hertz, jusqu'à ce qu'ils atteignent 0.

Minuterie système : cette minuterie est destinée à la synchronisation des événements de jeux. Sa valeur peut être réglée et lue.
Minuterie sonore : cette minuterie est utilisée pour les effets sonores. Lorsque sa valeur est différente de zéro, un signal sonore est émis. Sa valeur peut être réglée et lue.

La Chip 8 a besoin de deux variables pour se charger de la synchronisation et du son. Nous les appellerons respectivement compteurJeu et compteurSon.
Puisqu'elles doivent décompter à 60 hertz, il faut trouver une méthode pour les décrémenter toutes les 1 / 60 = 0,016 = 16 millisecondes. Les timers restent une bonne solution pour effectuer ce genre d'opération. En SDL, on implémente cette action avec SDL_Delay.

Toutes les caractéristiques de la Chip 8 seront stockées dans une structure qui représentera le CPU.

#ifndef CPU_H
#define CPU_H
#define TAILLEMEMOIRE 4096
#define ADRESSEDEBUT 512
typedef struct
{
Uint8 memoire[TAILLEMEMOIRE];
Uint8 V[16]; //le registre
Uint16 I; //stocke une adresse mémoire ou dessinateur
Uint16 saut[16]; //pour gérer les sauts dans « mémoire », 16 au maximum
Uint8 nbrsaut; //stocke le nombre de sauts effectués pour ne pas dépasser 16
Uint8 compteurJeu; //compteur pour la synchronisation
Uint8 compteurSon; //compteur pour le son
Uint16 pc; //pour parcourir le tableau « mémoire »
} CPU;
CPU cpu; //déclaration de notre CPU
void initialiserCpu() ;
void decompter() ;
#endif
#include "cpu.h"
void initialiserCpu()
{
//On initialise le tout
Uint16 i=0;
for(i=0;i<TAILLEMEMOIRE;i++) //faisable avec memset, mais je n'aime pas cette fonction ^_^
{
cpu.memoire[i]=0;
}
for(i=0;i<16;i++)
{
cpu.V[i]=0;
cpu.saut[i]=0;
}
cpu.pc=ADRESSEDEBUT;
cpu.nbrsaut=0;
cpu.compteurJeu=0;
cpu.compteurSon=0;
cpu.I=0;
}
void decompter()
{
if(cpu.compteurJeu>0)
cpu.compteurJeu--;
if(cpu.compteurSon>0)
cpu.compteurSon--;
}

Maintenant, attaquons le graphique, cela nous permettra de voir rapidement les différents résultats. L'ordre d'implémentation des caractéristiques importe peu, vous pourriez commencer par le graphique ou même l'exécution des instructions si vous le vouliez (par contre, je ne vous le conseille pas). :-°
Cet ordre nous permettra de faire des tests le plus tôt possible.

Le graphique

Jetons un coup d'œil à la description de la Chip 8 :

Citation

La résolution de l'écran est de 64 × 32 pixels, et la couleur est monochrome .

Pour simuler notre écran, nous allons créer un panneau divisé en 64 × 32 pixels.

Création des pixels

Un pixel est un petit carré (ou rectangle) caractérisé par son abscisse, son ordonnée et sa couleur (ici, elle sera noire ou blanche car l'écran est monochrome). Dans notre cas, j'ai choisi des pixels carrés de côté 8. Vous pouvez fixer une dimension qui vous convient.

Voici le code C/SDL qui permet de définir notre pixel. (Un vrai zéro se doit de maîtriser la SDL.) :D

#ifndef PIXEL_H
#define PIXEL_H
#include <SDL/SDL.h>
typedef struct
{
SDL_Rect position; //regroupe l'abscisse et l'ordonnée
Uint8 couleur; //comme son nom l'indique, c'est la couleur
} PIXEL;
#endif

Après la création de notre pixel, nous allons maintenant créer l'écran en tant que tel, qui sera constitué de 64 × 32 pixels.
Nous allons donc d'abord déclarer un tableau de 64 × 32 pixels et l'écran qui les contiendra. Cet écran aura des dimensions proportionnelles au nombre de pixels et à leur largeur.

#ifndef PIXEL_H
#define PIXEL_H
#include <SDL/SDL.h>
#define NOIR 0
#define BLANC 1
#define l 64 //nombre de pixels suivant la largeur
#define L 32 //nombre de pixels suivant la longueur
#define DIMPIXEL 8 //pixel carré de côté 8
#define WIDTH l*DIMPIXEL //largeur de l'écran
#define HEIGHT L*DIMPIXEL //longueur de l'écran
typedef struct
{
SDL_Rect position; //regroupe l'abscisse et l'ordonnée
Uint8 couleur; //comme son nom l'indique, c'est la couleur
} PIXEL;
SDL_Surface *ecran,*carre[2];
PIXEL pixel[l][L];
#endif

Maintenant que nous avons déclaré notre tableau de pixels, le premier petit problème pointe le bout de son nez.

Comment calculer les coordonnées de notre pixel à partir de l'indice du tableau ?

La technique est assez utilisée et connue mais un petit rappel est toujours le bienvenu.
Jetons un coup d'œil sur notre futur panneau avec tous ses pixels.

Image utilisateur

Chaque carré représente un pixel. Le pixel en (0,0) a pour coordonnées (0,0). De même, le pixel en (2,0) a pour coordonnées (2*8,0) soit (16,0). Enfin, le pixel en (0,1) a pour coordonnées (0,1*8) soit (0,8).
D'une manière générale, pour trouver l'abscisse et l'ordonnée d'un pixel, il suffit de multiplier ses indices respectifs (X,Y) par la largeur et la longueur d'un pixel. Nous les avons fixés tous les deux à 8 (les pixels sont carrés).
Voici donc comment j'ai procédé pour le calcul :

#ifndef PIXEL_H
#define PIXEL_H
#include <SDL/SDL.h>
#define NOIR 0
#define BLANC 1
#define l 64 //nombre de pixels suivant la largeur
#define L 32 //nombre de pixels suivant la longueur
#define DIMPIXEL 8 //pixel carré de côté 8
#define WIDTH l*DIMPIXEL //largeur de l'écran
#define HEIGHT L*DIMPIXEL //longueur de l'écran
typedef struct
{
SDL_Rect position; //regroupe l'abscisse et l'ordonnée
Uint8 couleur; //comme son nom l'indique, c'est la couleur
} PIXEL;
SDL_Surface *ecran,*carre[2];
PIXEL pixel[l][L];
void initialiserPixel() ;
#endif
#include "pixel.h"
void initialiserPixel()
{
Uint8 x=0,y=0;
for(x=0;x<l;x++)
{
for(y=0;y<L;y++)
{
pixel[x][y].position.x=x*DIMPIXEL;
pixel[x][y].position.y=y*DIMPIXEL;
pixel[x][y].couleur=NOIR; //on met par défaut les pixels en noir
}
}
}

Pour la couleur des pixels, j'ai adopté le même codage que la Chip 8, à savoir :

  • 0 pour le noir ou éteint ;

  • 1 pour le blanc ou allumé.

Envie de faire quelques tests ?

Rajoutons des fonctions pour initialiser les variables ecran et carre et pour dessiner sur notre écran.

#ifndef PIXEL_H
#define PIXEL_H
#include <SDL/SDL.h>
#define NOIR 0
#define BLANC 1
#define l 64
#define L 32
#define DIMPIXEL 8
#define WIDTH l*DIMPIXEL
#define HEIGHT L*DIMPIXEL
typedef struct
{
SDL_Rect position; //regroupe l'abscisse et l'ordonnée
Uint8 couleur; //comme son nom l'indique, c'est la couleur
} PIXEL;
SDL_Surface *ecran,*carre[2];
PIXEL pixel[l][L];
SDL_Event event; //pour gérer la pause
void initialiserEcran() ;
void initialiserPixel() ;
void dessinerPixel(PIXEL pixel) ;
void effacerEcran() ;
void updateEcran() ;
#endif
#include "pixel.h"
void initialiserPixel()
{
Uint8 x=0,y=0;
for(x=0;x<l;x++)
{
for(y=0;y<L;y++)
{
pixel[x][y].position.x=x*DIMPIXEL;
pixel[x][y].position.y=y*DIMPIXEL;
pixel[x][y].couleur=NOIR;
}
}
}
void initialiserEcran()
{
ecran=NULL;
carre[0]=NULL;
carre[1]=NULL;
ecran=SDL_SetVideoMode(WIDTH,HEIGHT,32,SDL_HWSURFACE);
SDL_WM_SetCaption("BC-Chip8 By BestCoder",NULL);
if(ecran==NULL)
{
fprintf(stderr,"Erreur lors du chargement du mode vidéo %s",SDL_GetError());
exit(EXIT_FAILURE);
}
carre[0]=SDL_CreateRGBSurface(SDL_HWSURFACE,DIMPIXEL,DIMPIXEL,32,0,0,0,0); //le pixel noir
if(carre[0]==NULL)
{
fprintf(stderr,"Erreur lors du chargement de la surface %s",SDL_GetError());
exit(EXIT_FAILURE);
}
SDL_FillRect(carre[0],NULL,SDL_MapRGB(carre[0]->format,0x00,0x00,0x00)); //le pixel noir
carre[1]=SDL_CreateRGBSurface(SDL_HWSURFACE,DIMPIXEL,DIMPIXEL,32,0,0,0,0); //le pixel blanc
if(carre[1]==NULL)
{
fprintf(stderr,"Erreur lors du chargement de la surface %s",SDL_GetError());
exit(EXIT_FAILURE);
}
SDL_FillRect(carre[1],NULL,SDL_MapRGB(carre[1]->format,0xFF,0xFF,0xFF)); //le pixel blanc
}
void dessinerPixel(PIXEL pixel)
{
/* pixel.couleur peut prendre deux valeurs : 0, auquel cas on dessine le pixel en noir, ou 1, on dessine alors le pixel en blanc */
SDL_BlitSurface(carre[pixel.couleur],NULL,ecran,&pixel.position);
}
void effacerEcran()
{
//Pour effacer l'écran, on remet tous les pixels en noir
Uint8 x=0,y=0;
for(x=0;x<l;x++)
{
for(y=0;y<L;y++)
{
pixel[x][y].couleur=NOIR;
}
}
//on repeint l'écran en noir
SDL_FillRect(ecran,NULL,NOIR);
}
void updateEcran()
{
//On dessine tous les pixels à l'écran
Uint8 x=0,y=0;
for(x=0;x<l;x++)
{
for(y=0;y<L;y++)
{
dessinerPixel(pixel[x][y]);
}
}
SDL_Flip(ecran); //on affiche les modifications
}
#include <SDL/SDL.h>
#include "cpu.h"
void initialiserSDL();
void quitterSDL();
void pause();
int main(int argc, char *argv[])
{
initialiserSDL();
initialiserEcran();
initialiserPixel();
updateEcran();
pause();
return EXIT_SUCCESS;
}
void initialiserSDL()
{
atexit(quitterSDL);
if(SDL_Init(SDL_INIT_VIDEO)==-1)
{
fprintf(stderr,"Erreur lors de l'initialisation de la SDL %s",SDL_GetError());
exit(EXIT_FAILURE);
}
}
void quitterSDL()
{
SDL_FreeSurface(carre[0]);
SDL_FreeSurface(carre[1]);
SDL_Quit();
}
void pause()
{
Uint8 continuer=1;
do
{
SDL_WaitEvent(&event);
switch(event.type)
{
case SDL_QUIT:
continuer=0;
break;
case SDL_KEYDOWN:
continuer=0;
break;
default: break;
}
}while(continuer==1);
}

Et voilà le résultat de tout ce travail. :-°

Image utilisateur

o_O Quoi ? Tout ce travail pour cette merde ! Un simple SDL_FillRect aurait fait l'affaire.

Modifier l'écran

Derrière tout ce travail se cache un grand secret. Je vous donne ce bout de code qui va vous éclaircir les idées. Remplacez la fonction initialiserPixel() par celle-ci :

void initialiserPixel()
{
Uint8 x=0,y=0;
for(x=0;x<l;x++)
{
for(y=0;y<L;y++)
{
pixel[x][y].position.x=x*DIMPIXEL;
pixel[x][y].position.y=y*DIMPIXEL;
if(x%(y+1)==0)
pixel[x][y].couleur=NOIR;
else
pixel[x][y].couleur=BLANC;
}
}
}

Et voilà le travail. :soleil:

Image utilisateur

Vous pouvez même changer la condition pour voir ce que donne le résultat. C'est tout simplement AMAZING!
C'est comme ça que le jeu se dessinera à l'écran. Il n'y aura pas de fichier image à charger ni quoi que ce soit ! Tout se fera en positionnant les pixels noirs et blancs comme il faut et en effectuant les différentes instructions requises. Nous les aborderons dans la partie suivante.
En revanche, n'oubliez pas de rétablir l'ancienne fonction initialiserPixel(). :-°

Nous avons fini de remplacer le matériel utilisé, il suffit maintenant de simuler les différents calculs que peut effectuer la Chip 8 et notre émulateur sera fini et opérationnel. Je sais : vous vous dites que c'est trop facile pour être vrai, mais c'est comme ça.
La suite… au prooochain numérooo !

Exemple de certificat de réussite
Exemple de certificat de réussite