Fonction MATRICE

0xDF : bloc incassable

0XB2 : Bloc piégé

0XF5 : Snoopy

0XA9: Balle

0Xb9 : Bloc cassable

0XDF : bloc apparition disparition

0XC5 : Oiseau

0xFE : bloc poussable

0xAF : Tapis roulant

CODE CP437

Fonction effacer
void effacer() {
// Crée une structure COORD pour représenter les coordonnées du coin
supérieur gauche
COORD topLeft = {0, 0};

// Déclare une structure pour stocker les informations sur le tampon

d'écran de la console
CONSOLE_SCREEN_BUFFER_INFO screen;

// Récupère le handle de la console standard de sortie

HANDLE console = GetStdHandle(STD_OUTPUT_HANDLE);

// Obtient des informations sur le tampon d'écran de la console (comme

la taille de la console)
GetConsoleScreenBufferInfo(console, &screen);

// Déclare une variable pour stocker le nombre d'octets écrits par la

fonction FillConsoleOutputCharacter
DWORD written;

// Remplit le tampon d'écran avec le caractère espace (' ') pour

effacer l'écran
FillConsoleOutputCharacter(console, ' ', screen.dwSize.X *
screen.dwSize.Y, topLeft, &written);

// Déplace le curseur de la console en haut à gauche (0, 0)

SetConsoleCursorPosition(console, topLeft);

// Appelle la fonction matrice1(matrice) pour réafficher la matrice

après l'effacement
matrice1(matrice);
}

Réinitialiser Niveau

void reinitialiserNiveau() {
// Réinitialiser les paramètres du niveau
ySnoopy = 5; // coordonnées initiales de snoopy pour replacer le
personnage
xSnoopy = 10;
vie = 3; // nombre de vie initiale réinitialiser

// Réinitialiser la matrice
for (int i = 0; i < 12; ++i) {
for (int j = 0; j < 22; ++j) {
matrice[i][j] = initialMatrice[i][j]; // redéfinition de la
matrice avec initialmatrice qui est la matrice initial
//On redonne donc à la matrice changé ces entrées du début
}
}
}

Blocs
#define MAX_BLOCS 100 // Le nombre maximal de blocs dans la structure est
défini à 100 on envisage de ne pas avoir plus de 100 blocs poussables.

typedef struct { // on défini une structutre dans laquelle on retrouve les

coordonées x et y des blocs et la valeur deplacé des blocs
int x;
int y;
int deplace;
} Bloc;
Bloc blocs[MAX_BLOCS]; // Déclare un tableau de structures Bloc appelé
blocs avec une taille maximale de 100 éléments, définie par MAX_BLOCS

void initBlocs() { //Débute la définition d'une fonction appelée initBlocs

qui initialise les blocs.
blocs[0].x = 1;
blocs[0].y = 2;
blocs[1].x = 17;
blocs[1].y = 2;
blocs[2].x = 12;
blocs[2].y = 4;
blocs[0].deplace = 0; // On initialise leur état de déplacement à 0
celui sera appellé à changer dans le déplacement
blocs[1].deplace = 0;
blocs[2].deplace = 0;

if (kbhit()){
char key = getch();
effacer();
switch (key) {
case 'z' :
if(ySnoopy> ymin)
{ if(matrice[ySnoopy-1][xSnoopy] == 0 || matrice[ySnoopy-
1][xSnoopy] == 0xC5 || matrice[ySnoopy-1][xSnoopy] == 0xB2 ) // Dans la
fonction déplacement on ajoute des conditions qui font que en plus des
limites le personnage peut se dépalcer en haut par z s'il y a aucun bloc ou
s'il y a un oiseau ou encore s'il y a aucun bloc piégé
ySnoopy--;
if (matrice[ySnoopy-1][xSnoopy] == 0xB9 ) // Ici on décrit
le bloc cassable qui fait que lorsque Snoopy est en-dessous d'un bloc
cassable celui se casse
matrice[ySnoopy-1][xSnoopy] = 0;
if (matrice[ySnoopy][xSnoopy] == 0xC5) //Ici de même
lorsque Snoopy est sur un oiseau celui disparaît
matrice[ySnoopy][xSnoopy] = 0;
if (matrice[ySnoopy][xSnoopy] == 0xB2) // Ici si snoopy est
sur un bloc piège cela fait appel à la fonction vie et baisse celle-ci
vie = vie-1;
for (int i=0 ;i<=3;i++) {
if (ySnoopy-1==blocs[i].y && xSnoopy == blocs[i].x &&
blocs[i].deplace == 0 && blocs[i].y != ymin+1 && 0 == matrice[ySnoopy-
2][xSnoopy]) { // Ici on définit les paramètres du bloc poussable il faut
donc que Snoopy soit juste en dessous du bloc poussable ici pour pouvoir le
déplacé en haut il faut aussi que ce bloc n'est pas été déplacé on verifie
donc cela avec la strucuture. Il faut aussi que ce bloc poussable soit en-
dessous d'une case vide et non pas d'un bloc, de même il faut que le bloc
poussable soit compris dans les limites
matrice[blocs[i].y][blocs[i].x] = 0; // On assigne
donc 0 à sa position initiale et son code hexadécimal à sa nouvelle
position en y-1
matrice[blocs[i].y-1][blocs[i].x] = 0xFE;
blocs[i].y--; //Ici on note les nouvelles
coordonnées du blocs dans la structure.
blocs[i].deplace = 1; //Et on transmet que ce bloc
a été déplacé en notant son numéro dans la boucle de 0 à 3 car il n'y a que
3 blocs poussable.
break;
}
}
}
break;
case 's' :
if(ySnoopy< ymax)
{
if (matrice[ySnoopy+1][xSnoopy] == 0 ||
matrice[ySnoopy+1][xSnoopy] == 0xC5 || matrice[ySnoopy+1][xSnoopy] == 0xB2)
ySnoopy++;
if (matrice[ySnoopy+1][xSnoopy] == 0xB9 )
matrice[ySnoopy+1][xSnoopy] = 0;
if (matrice[ySnoopy][xSnoopy] == 0xC5)
matrice[ySnoopy][xSnoopy] = 0;
if (matrice[ySnoopy][xSnoopy] == 0xB2)
vie = vie-1;

for (int i=0 ;i<=3;i++) {

if (ySnoopy+1==blocs[i].y && xSnoopy == blocs[i].x &&
blocs[i].deplace == 0 && blocs[i].y!=ymax-1 && 0 ==
matrice[ySnoopy+2][xSnoopy]) {
matrice[blocs[i].y][blocs[i].x] = 0;
matrice[blocs[i].y+1][blocs[i].x] = 0xFE;
blocs[i].y++;
blocs[i].deplace = 1;
break;
}
}

}
break;
case 'q' :
if(xSnoopy> xmin)
{
if (matrice[ySnoopy][xSnoopy-1] == 0 ||
matrice[ySnoopy][xSnoopy-1] == 0xC5 || matrice[ySnoopy][xSnoopy-1]== 0xB2)
xSnoopy--;
if (matrice[ySnoopy][xSnoopy-1] == 0xB9 )
matrice[ySnoopy][xSnoopy-1] = 0;
if (matrice[ySnoopy][xSnoopy] == 0xC5)
matrice[ySnoopy][xSnoopy] = 0;
if (matrice[ySnoopy][xSnoopy] == 0xB2)
vie = vie-1;

for (int i=0 ;i<=3;i++) {

if (ySnoopy == blocs[i].y && xSnoopy-1 == blocs[i].x &&
blocs[i].deplace == 0 && blocs[i].x!=xmin+1 && 0 ==
matrice[ySnoopy][xSnoopy+-2] ) {
matrice[blocs[i].y][blocs[i].x] = 0;
 matrice[blocs[i].y][blocs[i].x-1] = 0xFE;
blocs[i].x--;
blocs[i].deplace = 1;
break;
}
}

}
break;
case 'd' :

if(xSnoopy< xmax)
{
if (matrice[ySnoopy][xSnoopy+1] == 0 ||
matrice[ySnoopy][xSnoopy+1] == 0xC5 || matrice[ySnoopy][xSnoopy+1]==0xB2)
xSnoopy++;
if (matrice[ySnoopy][xSnoopy+1] == 0xB9)
matrice[ySnoopy][xSnoopy+1] = 0;
if (matrice[ySnoopy][xSnoopy] == 0xC5)
matrice[ySnoopy][xSnoopy] = 0;
if (matrice[ySnoopy][xSnoopy] == 0xB2)
vie = vie-1;

for (int i=0 ;i<=3;i++) {

if (ySnoopy==blocs[i].y && xSnoopy+1 == blocs[i].x &&
blocs[i].deplace == 0 && blocs[i].x != xmax-1 && 0 ==
matrice[ySnoopy][xSnoopy+2]) {
matrice[blocs[i].y][blocs[i].x] = 0;
matrice[blocs[i].y][blocs[i].x+1] = 0xFE;
blocs[i].x++;
blocs[i].deplace = 1;
break;
}
}

}
}