JEU DE PACMAN
Partie 3 : Le jeu

------------------------------------------------------------------

Afficher le plateau :

Dans le jargon, ce qu'on appele les "tiles" (lire en anglais!) ce sont les images qui sont utilisés pour représenter une case d'un plateau de jeu, c'est ce que l'on a traditionellement dans Zelda par exemple.
Ici, on va afficher chacune des 25x25=625 tiles carrées de 20 pixels (de coté) en fonction des données présente dans notre tableau en deux dimensions "board". Notre plateau sera enfin opérationnel!
Mais il faut tout d'abord créer les sprites des tiles et les inserer dans le dossier de votre projet, les voicis :
0.bmp :
1.bmp :
2.bmp :
3.bmp :
Elles sont très sommaires, oui, mais c'est juste pour faire marcher notre pacman!

C'est parti :

Code: Tout sélectionner

#include <allegro.h>

#define SIZE 25

// Pour alleger le code :
void exit_on_error(char* error_message)
{
    allegro_message(error_message);
    exit(-1);
}

// reste inchangé a par la résolution
void init()
{
    int res;
    allegro_init();
    set_color_depth(32);
    res = set_gfx_mode(GFX_AUTODETECT_WINDOWED, SIZE*20, SIZE*20, 0, 0);
    if (res != 0) exit_on_error("Impossible de charger le mode graphique");

    install_timer();
    install_keyboard();
}

void deinit()
{
    clear_keybuf();
}

int main()
{
    // Varibles pour les graphismes
    BITMAP *buffer;
    BITMAP *tile[4];

    //Variables temporaires
    int i,j;       // pour les boucles for

    // Variables du jeu
    char quit = 0; // rôle booléen
    int board[SIZE][SIZE];

    // Initialisation d'Allegro
    init();

    // Chargement des images des sprites APRES init()
    tile[0] = load_bitmap("0.bmp", NULL);
    tile[1] = load_bitmap("1.bmp", NULL);
    tile[2] = load_bitmap("2.bmp", NULL);
    tile[3] = load_bitmap("3.bmp", NULL);
    for (i=0;i<4;i++) if (!tile[i]) exit_on_error("Impossible de lire une tile.");

    // Création du buffer
    buffer = create_bitmap(SIZE*20, SIZE*20);
    if (!buffer) exit_on_error("Impossible d'allouer le buffer.");
   
    // Remplissage de board (sans lire un fichier pour le moment)
    for (i=0;i<SIZE;i++)
       for (j=0;j<SIZE;j++)
          board[i][j] = (i+j)%4; // par exemple, juste pour voir nos 4 sprites

    while (!quit)
    {
        if (key[KEY_ESC]) quit = 1;
       
        // On dessine les tiles
        for (i=0;i<SIZE;i++)
           for (j=0;j<SIZE;j++)
              draw_sprite(buffer, tile[board[i][j]], i*20, j*20);

        // On balance le tout sur l'écran       
        blit(buffer, screen, 0, 0, 0, 0, SIZE*20, SIZE*20);
    }

    // Fin du programme
    destroy_bitmap(buffer);
    for (i=0;i<4;i++) destroy_bitmap(tile[i]);

    return 0;
}
END_OF_MAIN()

Le résultat (très moche certes) :



Charger le plateau d'un fichier :

Alors là c'est du méga brutal, mais je voulais pas me casser la tête, je lis le fichier à l'ancienne : caractère par caractère. Pour des raisons d'évitage de bug, le fichier doit contenir EXACTEMENT SIZE*SIZE (=625 ici) caractères (0, 1, 2 ou 3 cf chapitre 1).
Voici votre fichier "board.txt" (toujours a rajouter dans le dossier de votre projet) : board.txt
ATTENTION : ne pas rajouter d'espaces ou de saut de lignes, même en fin de fichier! (c'est pas ce qu'on peut appeler de la flexibilité mais ça marche! Quitte à créer un éditeur de niveaux plus tard... lol)

Voici le code à inserer dans le main du programme précedant (en enlevant au préalable le remplissage "de test" du tableau board) :

Code: Tout sélectionner

#include <stdio.h> // A ne pas oublier!
(...)

    //Variables temporaires
    FILE *board_file;
    char c;

    (...) // Autres initialisations ici

    // Lecture plateau dans "board.txt" qui doit faire EXACTEMENT SIZE*SIZE caractères
    board_file = fopen("board.txt", "r");
    if (board_file==NULL) exit_on_error("Impossible d'ouvrir \"board.txt\"");
   
    i = 0;
    do
    {
        if (i>SIZE*SIZE) exit_on_error("\"board.txt\" trop long");
        c = fgetc(board_file);
        switch (c)
        {
               case '1' : board[i%SIZE][i/SIZE] = 1;
                          break;
               case '3' : board[i%SIZE][i/SIZE] = 3;
                          break;
               case '2' : board[i%SIZE][i/SIZE] = 2;
                          break;
               case '0' : board[i%SIZE][i/SIZE] = 0;
                          break;
        }
        i++;
    } while (c != EOF);
    if (i<=SIZE*SIZE) exit_on_error("\"board.txt\" trop court");
   
    fclose(board_file);

    // et hop vous pouvez utiliser votre board !

Je ne m'attarderais pas sur le fonctionnement de la lecture de fichiers mais plutot sur le remplissage du tableau 2D a partir d'un flux de données comme celui du fichier :

Code: Tout sélectionner

board[i%SIZE][i/SIZE]

- l'opérateur % est le modulo (le reste de la division entière)
- l'opérateur / est la division entière

Pour tout i entier, le modulo "i%n" est un entier compris entre 0 et n-1.
Et on sait (d'après la division euclidienne) que i == n*(i/n) + i%n. Si c'est un peu trop mathématique pour vous, contentez-vous de savoir que par exemple 23%9 == 5 (on enlève le maximum de fois 9 dans 23) et 23/9 == 2 (c'est le nombre de fois qu'on a enlevé 9 de 23). Compris?

Au final, on obtient ce que l'on veut (magie!) :



Pacman mon nouvel ami :

Voici notre Pacman : .
Pour le moment on va rajouter son affichage dans notre jeu et on va l'orienter selon la flèche du clavier préssée (sans le déplacer pour le moment).

Il existe des fonctions de symétrie horizontale et verticale pour les sprites, on peut aussi en théorie les faire tourner d'un certain angle. En théorie car il s'avère que ces fonctions de rotations ne fonctionnent pas chez moi (ou alors c'est moi qui sait pas les faire fonctionner!). On va donc utiliser un second sprite avec une pré-rotation de 90° :

On va commencer par rajouter plusieurs variables :

Code: Tout sélectionner

    // Varibles pour les graphismes
    BITMAP *s_pacman[4];

    // Variables du jeu
    int pacman_x = 12;
    int pacman_y = 16;
    int pacman_d  = 1;

Le tableau de 4 sprites "s_pacman" représente les quatres orientations de pacman selon sa direction de déplacement. Sa direction de déplacement est stockée dans l'entier "pacman_d" : 0 signifie haut, 1 signifie droite, 2 signifie bas et enfin 3 signifie gauche.

Regardons maintenant la création des deux autres sprites de pacman bas et gauche (on à déjà droite et haut!) :

Code: Tout sélectionner

    s_pacman[0] = load_bitmap("pacman2.bmp", NULL);
    s_pacman[1] = load_bitmap("pacman.bmp", NULL);
    s_pacman[2] = create_bitmap(20, 20);
    s_pacman[3] = create_bitmap(20, 20);
    for (i=0;i<4;i++) if (!s_pacman[i]) exit_on_error("Impossible de lire un sprite pacman.");

    // "Mirroir" du sprite pacman
    draw_sprite_v_flip(s_pacman[2], s_pacman[0], 0, 0);
    draw_sprite_h_flip(s_pacman[3], s_pacman[1], 0, 0);
   
    (...)

    // Fin du programme
    for (i=0;i<4;i++) destroy_bitmap(s_pacman[i]);

L'implémentation de draw_sprite_v_flip (ou h_flip) :

Code: Tout sélectionner

void draw_sprite_v_flip(BITMAP *bmp, BITMAP *sprite, int x, int y);

Maintenant il nous faut lire le clavier, rien de plus simple, rajouter ce qui suit sous "if (key[KEY_ESC]) quit = 1;" :

Code: Tout sélectionner

    if (key[KEY_UP])    pacman_d = 0;
    if (key[KEY_RIGHT]) pacman_d = 1;
    if (key[KEY_DOWN])  pacman_d = 2;
    if (key[KEY_LEFT])  pacman_d = 3;

Il reste plus qu'a l'afficher, rajouter ce qui suit entre le dessin du plateau et le blit du buffer :

Code: Tout sélectionner

draw_sprite(buffer, s_pacman[pacman_d], pacman_x*20, pacman_y*20);

Facile non?

Voici le code source complet :

Code: Tout sélectionner

#include <allegro.h>
#include <stdio.h>

#define SIZE 25

// Pour alleger le code :
void exit_on_error(char* error_message)
{
    allegro_message(error_message);
    exit(-1);
}

// reste inchangé a par la résolution
void init()
{
    int res;
    allegro_init();
    set_color_depth(32);
    res = set_gfx_mode(GFX_AUTODETECT_WINDOWED, SIZE*20, SIZE*20, 0, 0);
    if (res != 0) exit_on_error("Impossible de charger le mode graphique");

    install_timer();
    install_keyboard();
}

void deinit()
{
    clear_keybuf();
}

int main()
{
    // Varibles pour les graphismes
    BITMAP *buffer;
    BITMAP *tile[4];
    BITMAP *s_pacman[4];

    //Variables temporaires
    int i,j;       // pour les boucles for
    FILE *board_file;
    char c;

    // Variables du jeu
    char quit = 0; // rôle booléen
    int pacman_x = 12;
    int pacman_y = 16;
    int pacman_d = 1;
    int board[SIZE][SIZE];

    // Initialisation d'Allegro
    init();

    // Chargement des images et buffer
    buffer = create_bitmap(SIZE*20, SIZE*20);
    if (!buffer) exit_on_error("Impossible d'allouer le buffer.");

    tile[0] = load_bitmap("0.bmp", NULL);
    tile[1] = load_bitmap("1.bmp", NULL);
    tile[2] = load_bitmap("2.bmp", NULL);
    tile[3] = load_bitmap("3.bmp", NULL);
    for (i=0;i<4;i++) if (!tile[i]) exit_on_error("Impossible de lire une tile.");

    s_pacman[0] = load_bitmap("pacman2.bmp", NULL);
    s_pacman[1] = load_bitmap("pacman.bmp", NULL);
    s_pacman[2] = create_bitmap(20, 20);
    s_pacman[3] = create_bitmap(20, 20);
    for (i=0;i<4;i++) if (!s_pacman[i]) exit_on_error("Impossible de lire un sprite pacman.");

    // "Mirroir" du sprite pacman
    draw_sprite_v_flip(s_pacman[2], s_pacman[0], 0, 0);
    draw_sprite_h_flip(s_pacman[3], s_pacman[1], 0, 0);

    // Chargement du plateau
    board_file = fopen("board.txt", "r");
    if (bf==NULL) exit_on_error("Impossible d'ouvrir \"board.txt\"");
   
    i = 0;
    do
    {
        if (i>SIZE*SIZE) exit_on_error("\"board.txt\" trop long");
        c = fgetc(board_file);
        switch (c)
        {
               case '1' : board[i%SIZE][i/SIZE] = 1;
                          break;
               case '3' : board[i%SIZE][i/SIZE] = 3;
                          break;
               case '2' : board[i%SIZE][i/SIZE] = 2;
                          break;
               case '0' : board[i%SIZE][i/SIZE] = 0;
                          break;
        }
        i++;
    } while (c != EOF);
    if (i<=SIZE*SIZE) exit_on_error("\"board.txt\" trop court");
   
    fclose(board_file);
   
    // Début du jeu
    while (!quit)
    {
        if (key[KEY_ESC])   quit = 1;
        if (key[KEY_UP])    pacman_d = 0;
        if (key[KEY_RIGHT]) pacman_d = 1;
        if (key[KEY_DOWN])  pacman_d = 2;
        if (key[KEY_LEFT])  pacman_d = 3;
       
        // On dessine les tiles
        for (i=0;i<SIZE;i++)
           for (j=0;j<SIZE;j++)
              draw_sprite(buffer, tile[board[i][j]], i*20, j*20);

        // On dessine pacman
        draw_sprite(buffer, s_pacman[pacman_d], pacman_x*20, pacman_y*20);   

        // On balance le tout sur l'écran       
        blit(buffer, screen, 0, 0, 0, 0, SIZE*20, SIZE*20);
    }

    // Fin du programme
    destroy_bitmap(buffer);
    for (i=0;i<4;i++)
    {
        destroy_bitmap(tile[i]);
        destroy_bitmap(s_pacman[i]);
    }
    deinit();

    return 0;
}
END_OF_MAIN()

Et le résultat avec notre pacman qui regarde suivant la fleche sur laquelle on appuye :



:arrow: Pacman a faim et veut des jambes :

Tout d'abord comptons combien on a de boules et de bonus sur le plateau en modifiant la lecture du fichier :

Code: Tout sélectionner

// Variables de jeu
int nb_boules = 0;
int nb_bonus = 0;

(...)     
        switch (c)
        {
               case '1' : board[i%SIZE][i/SIZE] = 1;
                          nb_boules++;
                          break;
               case '3' : board[i%SIZE][i/SIZE] = 3;
                          break;
               case '2' : board[i%SIZE][i/SIZE] = 2;
                          nb_bonus++;
                          break;
               case '0' : board[i%SIZE][i/SIZE] = 0;
                          break;
        }
(...)

Rien a dire ici! On affichera a l'écran ces deux entiers plus tard...
Pour déplacer votre pacman il suffit "simplement" de rajouter ce code a la place de la lecture clavier avant les dessins :

Code: Tout sélectionner

         if (key[KEY_ESC])   {quit = true; break;}
         if (key[KEY_UP])    if (board[pacman_x][pacman_y-1] != 3) pacman_d = 0;
         if (key[KEY_RIGHT]) if (board[pacman_x+1][pacman_y] != 3) pacman_d = 1;
         if (key[KEY_DOWN])  if (board[pacman_x][pacman_y+1] != 3) pacman_d = 2;
         if (key[KEY_LEFT])  if (board[pacman_x-1][pacman_y] != 3) pacman_d = 3;

         // On va sortir du plateau? -> déplacement automatique
         if (pacman_x == 0 && pacman_d == 3)           pacman_x = SIZE-1;
         else if (pacman_y == 0 && pacman_d == 0)      pacman_y = SIZE-1;
         else if (pacman_x == SIZE-1 && pacman_d == 1) pacman_x = 0;
         else if (pacman_y == SIZE-1 && pacman_d == 2) pacman_y = 0;
         else // Sinon déplacement normal de pacman
              switch (pacman_d)
              {
                   case 0 : if (board[pacman_x][pacman_y-1] != 3) pacman_y--; break;
                   case 1 : if (board[pacman_x+1][pacman_y] != 3) pacman_x++; break;
                   case 2 : if (board[pacman_x][pacman_y+1] != 3) pacman_y++; break;
                   case 3 : if (board[pacman_x-1][pacman_y] != 3) pacman_x--; break;
              };

C'est pas très joli mais c'est efficace!
Maintenant il faut le faire manger, rajoutez ceci juste après le code précedant :

Code: Tout sélectionner

         // Manger !
         switch (board[pacman_x][pacman_y])
         {
              case 1 : board[pacman_x][pacman_y] = 0;
                       nb_boules--;
                       break;
              case 2 : board[pacman_x][pacman_y] = 0;
                       nb_bonus--;
                       break;
         }
         if (nb_boules == 0 && nb_bonus == 0) quit = 1;


Pas de commentaires particuliers, avec un peu de réflexion ce code est assez simple. Mais il a été fait de sorte que quand vous appuyez dans une direction impossible pacman ne se stop pas et ne passe pas un tour de jeu sans bouger.

Vous pouvez compiler, vous avez un super pacman qui mange (et le jeu se termine quand vous avez tout mangé)... MAIS, gros probleme, le jeu va trop vite!!!


Timer à la rescousse :

Alors on est ici dans un point critique du jeu, la temporisation!
Je vous rapelle le schéma du moteur de jeu :

Le principe de notre timer est d'attendre que sufissament de temps se soit passé pour faire avancer et redessiner le jeu. Certes, mais une chose important est que durant cette phase d'attente nous lisions le clavier (sinon vous avez une chance infime d'appuyer sur la touche quand le programme fait son test). On va donc insérer un boucle "d'attente" qui se contentera de lire le clavier en permanence, puis on en sortira en temps venu!

Mettons en place ce fameux timer (de façon bizarre car très proche de la machine!).

Rajoutez ce code au début, en dehors de votre fonction main :

Code: Tout sélectionner

#define TIME_COUNT 10;   // Réduire pour accelerer le jeu

volatile int timer=0;  // Pour la temporisation

void incrementer_timer()
{
   timer++;
}
END_OF_FUNCTION(incrementer_timer);

Le volatile et cette fonction triviale sont présent pour des raisons machines pronfondes.
Ce qu'il vous faut savoir c'est que cette fonction incrementer_timer sera appelée a des intervalles réguliers (que l'on choisira plus loin), mais on a pas le droit de mettre nos procedures de dessin dedans, il faut qu'elle reste très très très simple.

Rajoutez ceci dans main() :

Code: Tout sélectionner

// Variables du jeu
int next_time = 0;

Rajoutez ceci à la fin de init() :

Code: Tout sélectionner

LOCK_VARIABLE(timer);
LOCK_FUNCTION(incrementer_timer);
install_int_ex(incrementer_timer, BPS_TO_TIMER(60));


et ceci dans deinit() ;

Code: Tout sélectionner

remove_int(incrementer_timer);

Et pour terminer, la boucle d'attente dans le corps du jeu :

Code: Tout sélectionner

         // Boucle "d'attente"
         while(timer<next_time)
         {
              if (key[KEY_ESC])   {quit = true; break;}
              if (key[KEY_UP])    if (board[pacman_x][pacman_y-1] != 3) pacman_d = 0;
              if (key[KEY_RIGHT]) if (board[pacman_x+1][pacman_y] != 3) pacman_d = 1;
              if (key[KEY_DOWN])  if (board[pacman_x][pacman_y+1] != 3) pacman_d = 2;
              if (key[KEY_LEFT])  if (board[pacman_x-1][pacman_y] != 3) pacman_d = 3;
         }

         next_time = timer + TIME_COUNT;

BPS_TO_TIMER(60) signifie que la fonction increment_timer sera appelée 60 fois par secondes, donc que timer est incrémenté de 60 toutes les secondes. Ensuite il faut juste savoir que la boucle d'attente tournera pendant TIME_COUNT unités de temps, ici le jeu tournera théoriquement a 6 images par secondes car TIME_COUNT vaut 10 (peut-être un peu moin dans la pratique).


Affichage de texte :

Afficher un texte et des variables avec Allegro est un vrai jeu d'enfant, rajoutez ce code avant le blit du dessin (n'hésitez pas a consulter la documentation de la librairie) :

Code: Tout sélectionner

// Variables temporaires
blanc = makecol32(255,255,255);
gris  = makecol32(128,128,128);

(...)

// A rajouter avant le "blit"
textprintf_ex(buffer, font, 0,   0, blanc, gris, "Pacman par Mandibull");
textprintf_ex(buffer, font, 0,  10, blanc, gris, "Boules : %i    Bonus : %i", nb_boules, nb_bonus);

Enfin, un dernier détail facultatif, pour accelerer les acces répétés a un bitmap (ici buffer) :

Code: Tout sélectionner

acquire_bitmap(buffer);

// Avec ici tout le dessin dans buffer
         
release_bitmap(buffer);

// Et là le blit...

Vous avez pas bien suivi? Voici le code source complet :

Code: Tout sélectionner

#include <allegro.h>
#include <stdio.h>       // Pour la lecture de fichier

#define SIZE 25
#define TIME_COUNT 10;   // Réduire pour accelerer le jeu

volatile int timer=0;    // Pour la temporisation

void incrementer_timer()
{
   timer++;
}
END_OF_FUNCTION(incrementer_timer);

// Pour alleger le code :
void exit_on_error(char* error_message)
{
     allegro_message(error_message);
     exit(-1);
}

// reste inchangé a par la résolution
void init()
{
   int res;
    allegro_init();
    set_color_depth(32);
    res = set_gfx_mode(GFX_AUTODETECT_WINDOWED, SIZE*20, SIZE*20, 0, 0);
   if (res != 0) exit_on_error("Impossible de charger le mode graphique");

   install_timer();
   install_keyboard();
   
    LOCK_VARIABLE(timer);
    LOCK_FUNCTION(incrementer_timer);
    install_int_ex(incrementer_timer, BPS_TO_TIMER(60));
}

void deinit()
{
    remove_int(incrementer_timer);
   clear_keybuf();
}

int main()
{
    // Varibles pour les graphismes
    BITMAP *buffer;
    BITMAP *s_pacman[4];
    BITMAP *tile[4];
   
    //Variables temporaires
    FILE *bf;
    char c;
    int i,j;
    int blanc, gris;
   
    // Variables du jeu
    int next_time = 0;
    bool quit = false;
    int board[SIZE][SIZE];
    int pacman_x  = 12;     // Position de pacman (pos initiale : 12,16)
    int pacman_y  = 16;
    int pacman_d  = 0;      // Direction de pacman 0=haut, 1=droite, 2=bas, 3=gauche
    int nb_boules = 0;
    int nb_bonus  = 0;

    // Initialisation d'Allegro et du timer
    init();

    // Lecture plateau dans "board.txt" qui doit faire EXACTEMENT SIZE*SIZE caractères
    bf = fopen("board.txt", "r");
    if (bf==NULL) exit_on_error("Impossible d'ouvrir \"board.txt\"");
   
    i = 0;
    do
    {
        if (i>SIZE*SIZE) exit_on_error("\"board.txt\" trop long");
        c = fgetc(bf);
        switch (c)
        {
               case '1' : board[i%SIZE][i/SIZE] = 1;
                          nb_boules++;
                          break;
               case '3' : board[i%SIZE][i/SIZE] = 3;
                          break;
               case '2' : board[i%SIZE][i/SIZE] = 2;
                          nb_bonus++;
                          break;
               case '0' : board[i%SIZE][i/SIZE] = 0;
                          break;
        }
        i++;
    } while (c != EOF);
    if (i<=SIZE*SIZE) exit_on_error("\"board.txt\" trop court");
   
    fclose(bf);

    // Chargement des sprites et création du buffer
    buffer = create_bitmap(SIZE*20, SIZE*20);
    if (!buffer) exit_on_error("Impossible d'allouer le buffer.");
       
    s_pacman[0] = load_bitmap("pacman2.bmp", NULL);
    s_pacman[1] = load_bitmap("pacman.bmp", NULL);
    s_pacman[2] = create_bitmap(20, 20);
    s_pacman[3] = create_bitmap(20, 20);
    for (i=0;i<4;i++) if (!s_pacman[i]) exit_on_error("Impossible de lire un sprite pacman.");

    tile[0] = load_bitmap("0.bmp", NULL);
    tile[1] = load_bitmap("1.bmp", NULL);
    tile[2] = load_bitmap("2.bmp", NULL);
    tile[3] = load_bitmap("3.bmp", NULL);
    for (i=0;i<4;i++) if (!tile[i]) exit_on_error("Impossible de lire une tile.");
   
    // "Mirroir" du sprite pacman
    draw_sprite_v_flip(s_pacman[2], s_pacman[0], 0, 0);
    draw_sprite_h_flip(s_pacman[3], s_pacman[1], 0, 0);
   
    // Dernier détail
    blanc = makecol32(255,255,255);
    gris  = makecol32(128,128,128);
       
    // Le jeu!
   while (!quit)
    {
         // Boucle "d'attente"
         while(timer<next_time)
         {
              if (key[KEY_ESC])   {quit = true; break;}
              if (key[KEY_UP])    if (board[pacman_x][pacman_y-1] != 3) pacman_d = 0;
              if (key[KEY_RIGHT]) if (board[pacman_x+1][pacman_y] != 3) pacman_d = 1;
              if (key[KEY_DOWN])  if (board[pacman_x][pacman_y+1] != 3) pacman_d = 2;
              if (key[KEY_LEFT])  if (board[pacman_x-1][pacman_y] != 3) pacman_d = 3;
         }

         next_time = timer + TIME_COUNT;

         // On va sortir du plateau? -> déplacement automatique
         if (pacman_x == 0 && pacman_d == 3)           pacman_x = SIZE-1;
         else if (pacman_y == 0 && pacman_d == 0)      pacman_y = SIZE-1;
         else if (pacman_x == SIZE-1 && pacman_d == 1) pacman_x = 0;
         else if (pacman_y == SIZE-1 && pacman_d == 2) pacman_y = 0;
         else // Sinon déplacement normal de pacman
              switch (pacman_d)
              {
                   case 0 : if (board[pacman_x][pacman_y-1] != 3) pacman_y--; break;
                   case 1 : if (board[pacman_x+1][pacman_y] != 3) pacman_x++; break;
                   case 2 : if (board[pacman_x][pacman_y+1] != 3) pacman_y++; break;
                   case 3 : if (board[pacman_x-1][pacman_y] != 3) pacman_x--; break;
              };
         
         // Manger !
         switch (board[pacman_x][pacman_y])
         {
              case 1 : board[pacman_x][pacman_y] = 0;
                       nb_boules--;
                       break;
              case 2 : board[pacman_x][pacman_y] = 0;
                       nb_bonus--;
                       break;
         }
         if (nb_boules == 0 && nb_bonus == 0) quit = 1;
         
         // DESSINS
         
         acquire_bitmap(buffer); // petit détail pour les perfs graphiques
         
         // Dessin du plateau
         for (i=0;i<SIZE;i++)
             for (j=0;j<SIZE;j++)
                 draw_sprite(buffer, tile[board[i][j]], i*20, j*20);

         // Dessin de pacman suivant sa direction
         draw_sprite(buffer, s_pacman[pacman_d], pacman_x*20, pacman_y*20);

         textprintf_ex(buffer, font, 0,   0, blanc, gris, "Pacman par Mandibull");
         textprintf_ex(buffer, font, 0,  10, blanc, gris, "Boules : %i    Bonus : %i", nb_boules, nb_bonus);
         
         release_bitmap(buffer); // va avec acquire_bitmap
         
         // On balance le tout sur l'écran       
         blit(buffer, screen, 0, 0, 0, 0, SIZE*20, SIZE*20);
   }

    // On détruit tout!
   deinit();

    destroy_bitmap(buffer);
    for (i=0;i<4;i++)
    {
        destroy_bitmap(tile[i]);
        destroy_bitmap(s_pacman[i]);
    }

   return 0;
}
END_OF_MAIN()

et le résultat :


Rendez-vous partie 4!

Dépeche toi ami pacman, on t'attend avec impatience.
Les 3 premières parties sont impeccables

Evolution : pacman en réseau pour jouer en salle info hein dams :D

Ok, j'suis sur le coup, il sera pret pour la fin des grèves ;P lol

lol, concernant le réseau c'est musclé. j'ai jamais fabriqué de jeu en réseau, mais j'ai déjà manipulé le réseau à la main. Si on veut on jeu en réseau fodré tout recommencer en Direct 3D pour utiliser Direct Play (de Direct X) :p

Pacman est arrivé mais il a pas de jambes encore!

Sinon Dams tu programmes un peu?

Tuto fini, je le poste dans les news les autres n'hésitez pas à dire ce que vous en pensez !!!!

hmmm, très bon tuto.
Je viens de le lire, je ne l'ai pas encore testé mais j'ai compris exactement la logique du déroulement de l'algorithme.

Meme si l'implantation du timer reste un peu floue (je pense qu'il faut tout simplement que je le test pour comprendre ), Toutes les nouvelles fonctions et variables s'intègrent parfaitement, tout est clair.

Enfin bref, tout ça pour dire:

Vivement la partie 4

Quel psychopath ce mandib ! Très très bon, mais qu'il est moche ton source loooool, j'ai pas l'habitude des fonctions de 300 lignes :p.

Sinon Dams, le timeur se concoit bien une fois que tu t'es confronté à la réalité des choses :D.

Oui, c'est bon j'ai testé.

Juste un p'tit truc, ta variable quit, tu l'initialise en tant que bool et parfois t'y affect un entier.
Avant de tout mettre en int, j'ai test de les mettre en booléen (boolean, bool) mais la déclaration fait planter la compilation.
Donc est-ce que je fais mal les choses ou est-ce que le Langage C ne connait pas les boolean ?
(enfin ce qui m'étonnerais car il reconnait le mot-clé "bool").

Alors pour WydD, ouais c'est une grosse fonction moche. J'ai pas pu découper en fonctions pour plusieurs raisons dont la plus grave est que si je découpe tout en fonction j'aurais pas acces aux variables de jeu dans mes fonctions (j'aurais pu mettre ces variables en dehors du main en tant que variables globales... mais bon c'est pas super propre non plus). Soit il faut les passer en paramètres (beurk!), soit y faut tout revoir la construction du jeu ! Le plus propre étant de créer différentes classes : Cjeu, Cboard, Cperso (qui donneront Cpacman et Cghost)... mais là ça devient assez sportif pour un débutant

Juste un p'tit truc, ta variable quit, tu l'initialise en tant que bool et parfois t'y affect un entier.

Dans la partie 3 elle est initialisé en tant que char. En fait c'est un bout de vieux code qui est resté dans la partie 2.

Car, oui j'ai eut le même problème, le type "bool" n'est pas implémenté en C norme ANSI (je travaille en C++ d'habitude), donc je l'ai remplacé par un "char" (ce qui revient EXACTEMENT au meme) sauf que tu mets 1 à la place de true et 0 à la place de false...
(si t'es pas content tu fais #define true 1 et #define false 0 )

Donc j'ai corrigé ce p'tit pb qui était resté dans la partie 2 (mais pas dans la 3)! Merci

Encore une petite précision avec le timer pour éclaircir les idées.

Ce que l'on a envie de faire au premier abord c'est une sorte "delay", c'est a dire une fonction qui attend un certain nombre de millisecondes.

L'idée n'est pas bête mais on rencontre un probleme majeur : cette fonction monopolise votre programme et vous empeche d'effectuer quoi que ce soit !

Regardez :

Code: Tout sélectionner

while (!quit)
{
     delay(300); // on attend 300ms

     if (key[KEY_ESC]) quit = true;
     
     // CALCULS + AFFICHAGE
}

Ici l'utilisateur peut appuyer sur son clavier autant qu'il veut durant les 300 ms en théorie ça ne sera pas pris en compte vu que le programme est occupé, il faudra appuyer sur Echap au moment où le if est testé ! (c'est a dire dans un laps de temps vraiment miniscule)

D'ou l'obligation d'avoir une boucle qui teste le clavier en permanence

C'est ce qui se passe dans windows, par exemple, quand les programmes communiquent avec l'OS : ils attendent en permanence un "message" (clavier, souris, fermeture, réduction, afficher...). Et quand un programme "bug" : que vous ne pouvez plus le fermer, ou qu'il laisse la trainée de vos autres fenêtres, c'est qu'il ne répond plus aux messages windows (en quelque sorte) !

Plus grave encore, dans un "vrai" jeu, il est IMPERATIF de faire des calculs en permanence, donc hors de question de faire attendre le jeu ! Il faut rentabiliser le temps et pas seulement lire le clavier!


Maintenant le fait de créer une fonction un peu spéciale, et de faire appel au entrailles de votre système, là je ne peux pas vous expliquer si ce n'est que ça permet d'avoir un timer personnalisé et performant.

On aurait peut être pu utiliser un timer déjà présent, celui qui régule windows par exemple... mais je ne pense pas que ça soit possible. Et ne comptez pas utiliser un timer "classique" celui qui vous donner l'heure, il est beaucoup trop lent !!!

A oui, je me souviens maintenant du char qui s'utilise comme booléen (j'ai appris le C mais je l'ai pas beaucoup utilisé, je suis plutot Java ;p)
Et merci aussi de la précision sur le timer, c'est vrai qu'avant de bien lire l'algo, je pensais à ça, une vrai "pause de l'algo" donc aucun traitement, c'est pour ca que c'etait un peu flou, mais une fois qu'on regarde de plus près, ça devient plus clair :p

Si ça t'éclairci les idées tant mieux et de rien! Posez vos autres questions chuis là pour ça!