SIMPLE JEU DU SERPENT

#include <stdlib.h>
#include <SDL/SDL.h>
#include <time.h>

#define N         500 /*taille maximale du snake*/
#define NODESIZE  10  /*largeur et hauteur d'une case*/
#define WINSIZE   400 /*largeur et hauteur de la fenêtre*/

/********************************* types **************************************/

typedef enum {Up, Down, Right, Left}TDirection; /*type de direction*/

/******************************************************************************/

/********************************* ecran **************************************/

SDL_Surface* screen = NULL; /*ecran principal*/
SDL_Surface* Table[N] = {NULL}; /*tableau des nodes du snake*/
SDL_Surface* blank; /*fond d'ecran*/
SDL_Surface* puce; /*puce à bouffer ^^*/

/******************************************************************************/

/********************************* positions **********************************/

SDL_Rect     Tabpos[N], /*tableau des positions des node du snake*/
             ppuce; /*position de la puce*/

/******************************************************************************/

/*********************************** Divers ***********************************/

int NodeCounter; /*représente le nombre de node actuel du snake*/

TDirection direction; /*Direction actuel du snake*/
SDL_TimerID timer; /*descripteur du timer*/

/******************************************************************************/

/************************* Prototypes des fonctions ***************************/

Uint32 Anime_it    (Uint32, void *);
int snakeColl      (void);

void Quitter      (void);
void SetPos       (void);
void MoveSnake    (void);
void Show         (void);
void PurgeScreen  (void);
void SetPuce      (void);
void Lose         (void);
void freeNodes    (void);
void AddNode      (void);

/******************************************************************************/

int main ( int argc, char** argv )
{

    Uint32 speed; /*vitesse du snake*/

    SDL_Event event;

    int done; /*vaiable de la boucle du jeu*/
    int i; /*variable de contrôle*/


     srand (time(NULL)); /*initialisation du générateur pseudo-aléatoire*/

            /*initialisation de la lib SDL*/
     i = SDL_Init (SDL_INIT_VIDEO|SDL_DOUBLEBUF| SDL_INIT_TIMER);
      if (i < 0){
        fprintf (stderr, "Erreur de chargement: %s", SDL_GetError());
          exit(EXIT_FAILURE);
          }
     atexit (Quitter);

     screen = SDL_SetVideoMode (WINSIZE, WINSIZE, 32, SDL_HWSURFACE);
      if (screen == NULL){
         fprintf (stderr, "J'arrive pas à appliquer le mode 640x480: %s", SDL_GetError ());
          exit (EXIT_FAILURE);
          }

       SDL_WM_SetCaption ("Simple Snake Game by Agent-G", NULL);

     /*Initialisations*/
         speed = 30;
         done = 1;
         NodeCounter = 10;
         direction = Right;

        Table[0] = SDL_CreateRGBSurface(SDL_HWSURFACE, NODESIZE, NODESIZE, 32, 0, 0, 0, 0);
        SDL_FillRect (Table[0], NULL, SDL_MapRGB (Table[0]->format, 0, 255, 0));
        Tabpos[0].x = screen->w/2;
        Tabpos[0].y = screen->h/2;

         for (i=1; i<NodeCounter; i++){
           Table[i] = SDL_CreateRGBSurface(SDL_HWSURFACE, NODESIZE, NODESIZE, 32, 0, 0, 0, 0);
           SDL_FillRect (Table[i], NULL, SDL_MapRGB (Table[i]->format, 0, 255, 0));
           Tabpos[i].x = Tabpos[i-1].x - NODESIZE;
           Tabpos[i].y = screen->h/2;
             }



     Show ();
     SDL_Flip (screen);

     timer = SDL_AddTimer(1, Anime_it, &speed);
     SetPuce ();
     while (done){

        SDL_WaitEvent (&event);

         switch (event.type){

             case SDL_QUIT:
                   done  = 0;
                   break;

              case SDL_KEYDOWN:
                     switch (event.key.keysym.sym){
                        case SDLK_UP:
                         if (direction != Down)
                           direction = Up;
                           break;
                        case SDLK_DOWN:
                         if (direction != Up)
                           direction = Down;
                           break;
                        case SDLK_RIGHT:
                         if (direction != Left)
                           direction = Right;
                           break;
                        case SDLK_LEFT:
                         if (direction != Right)
                           direction = Left;
                           break;
                        case SDLK_u: /*auguemente la vitesse*/
                          if ((speed-5)>0)
                            speed-=5;
                           break;
                        case SDLK_l:/*baisse la vitesse*/
                          if ((speed+5)<100)
                            speed+=5;
                           break;
                        case SDLK_ESCAPE:
                          done  = 0;
                          break;
                         }
                        break;
                 }/*SWITCH*/
          }/*WHILE*/


    return 0;
}




void MoveSnake (){
/*s'occupe de faire bouger le snake*/
     switch (direction){

        case Up:
         if ((Tabpos[0].y - NODESIZE)>=0)
           Tabpos[0].y -= NODESIZE;
          else
            Lose ();
          break;
        case Down:
         if ((Tabpos[0].y + NODESIZE)< screen->h)
           Tabpos[0].y += NODESIZE;
          else
            Lose ();
          break;
        case Right:
         if ((Tabpos[0].x + NODESIZE)< screen->w)
           Tabpos[0].x += NODESIZE;
          else
            Lose ();
          break;
        case Left:
         if ((Tabpos[0].x - NODESIZE)>= 0)
           Tabpos[0].x -= NODESIZE;
          else
            Lose ();
          break;
         }
   /*on vérifi si on a bouffé quelque chose, et si oui on ajoute un node*/
   if ((Tabpos[0].x == ppuce.x)&&(Tabpos[0].y == ppuce.y))
      AddNode ();
  /*s'il le snake heurte sa queu, paffff lose :)*/
   if (snakeColl()) Lose();

    }

void SetPos (void){
/*application des modifications sur les positions des nodes de la queu du snake*/
   int i;

    for (i=(NodeCounter-1); i>0; i--){
      Tabpos[i].x = Tabpos[i-1].x;
      Tabpos[i].y = Tabpos[i-1].y;
       }
    }

void Show (void){
/*blit toutes les surfaces sur l'ecran principales avant rafraichissement*/
   int i;

    for (i=0; i<NodeCounter; i++)
      SDL_BlitSurface (Table[i], NULL, screen, &Tabpos[i]);

      SDL_BlitSurface (puce, NULL, screen, &ppuce);
    }

void Quitter (void){

    freeNodes ();
    SDL_FreeSurface (puce);

   SDL_Quit();

    }

void PurgeScreen (void){
/*Destruction de l'interface en insérant une surface toute blanche*/
    SDL_Rect p;

     p.x = 0;
     p.y = 0;

     blank = SDL_CreateRGBSurface(SDL_HWSURFACE, screen->h, screen->w, 32, 0, 0, 0, 0);
     SDL_FillRect (blank, NULL, SDL_MapRGB (blank->format, 255, 255, 255));
     SDL_BlitSurface (blank, NULL, screen, &p);
     SDL_FreeSurface (blank);

    }


void SetPuce (){
/*insértion d'une puce dans le jeu*/
  int genx, geny,
      flag = 1,
      cpt;

    while (flag){
      flag = 0;

       genx = (rand() % (WINSIZE/10))*NODESIZE;
      for (cpt=0; cpt<NodeCounter; cpt++)
         if (genx == Tabpos[cpt].x){
           flag = 1;
            break;
           }
        }

    flag = 1;
    while (flag){
      flag = 0;

       geny = (rand() % (WINSIZE/10))*NODESIZE;
      for (cpt=0; cpt<NodeCounter; cpt++)
         if (geny == Tabpos[cpt].y){
           flag = 1;
            break;
           }
        }

        puce = SDL_CreateRGBSurface(SDL_HWSURFACE, NODESIZE, NODESIZE, 32, 0, 0, 0, 0);
        SDL_FillRect (puce, NULL, SDL_MapRGB (puce->format, 255, 0, 0));
        ppuce.x = genx;
        ppuce.y = geny;
        SDL_BlitSurface (puce, NULL, screen, &ppuce);
    }

Uint32 Anime_it (Uint32 interval, void *param){
/*fonction callback du timer, elle fait bougé le snakouille :p*/
    Uint32 *t = (Uint32*)param;

       SDL_Delay (*t);
       MoveSnake ();
       SetPos ();
       PurgeScreen ();
       Show ();
       SDL_Flip (screen);

   return interval;
    }

void Lose (void){
/*bah si on a perdu on fais quelque chose ché po moi!*/
  SDL_RemoveTimer(timer);
      }


void freeNodes (void){
/*libération de la mémoire allouée pour les nodes*/
   int i;

   for (i=0; i<NodeCounter; i++)
      SDL_FreeSurface (Table[i]);

    }

void AddNode (void){
/*ajout d'un node au snake*/
   NodeCounter++;

    Table[NodeCounter-1] = SDL_CreateRGBSurface(SDL_HWSURFACE, NODESIZE, NODESIZE, 32, 0, 0, 0, 0);
    SDL_FillRect (Table[NodeCounter-1], NULL, SDL_MapRGB (Table[NodeCounter-1]->format, 0, 255, 0));
    SetPuce ();
     }

int snakeColl (void){
/*retourne 1 i le snake heurte sa queu :p*/
   int i,
      cl = 0;

   for (i=3; i<NodeCounter; i++)
     if ((Tabpos[0].x == Tabpos[i].x)&&(Tabpos[0].y == Tabpos[i].y)){
       cl = 1;
       break;
      }

      return cl;
    }