#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <SDL/SDL.h>
#include <SDL/SDL_ttf.h>
#define MAX_ENNEMIS 201
#define L_FENETRE 640
#define H_FENETRE 480
#define VALUE_PROIE 2
#define VALUE_BONUS 5
#define ECART 4

/* Objectif : création d'un jeu vidéo basique (SNAKE)
Auteur : Naji Mammeri */

enum typeProie
{
        PROIE, BONUS
};

/* Variables globales */
int     ennemisBouffes = 1,
        score = 0,
        i = 0,
        j = 0,
        k = 0;
enum typeProie typeProie = PROIE;


/* Vérification de la proximité de la proie / du bonus */
void approxVerif(struct SDL_Rect * positionProie,
                                struct SDL_Rect * positionSnake,
                                enum typeProie typeproie)
{
        /* Si le serpent passe près de la proie / du bonus, on considère ça comme un succès */
 for(k = 0; k <= ennemisBouffes; k++)
 {
  for(i = 0 - ECART ; i <= ECART ; i++)
  {
     if(positionSnake->x + i == positionProie->x)
     { /* Test abscisse */
         for(j = 0 - ECART ; j <= ECART ; j++)
         {
               if(positionSnake->y + j == positionProie->y)
               { /* Test ordonnée */
                                                       ennemisBouffes++;
                                                            if (positionnerProie(positionProie) != 1)
                                                                fprintf(stderr, "positionnerProie() incorrectly loaded");
                                                               
                                                                switch(typeproie)
                                                                {
                                                                case PROIE: score += VALUE_PROIE; break;
                                                                case BONUS: score += VALUE_BONUS; break;
                                                                }
               } /* Fin test ordonnée */
         }
     } /* Fin test abscisse */
  }
 }
  /* Fin de la boucle du test de proximité de la proie */
}


/* Fonction qui positionne la proie */
int positionnerProie(struct SDL_Rect * proie_position)
{
         srand(time(NULL)); /* initialisation du rand() */
     proie_position->x = (rand() % ( (L_FENETRE-20) - 20 + 1) ) + 20;
     proie_position->y = (rand() % ( (H_FENETRE-20) - 20 + 1) ) + 20;
         return 1;
}

/* Enumération qui fixe les directions possibles */
enum direction
{
     UP, DOWN, LEFT, RIGHT
};

/* Fonction servant à faire avancer les personnages dans la direction voulue */
void move(enum direction direction, int avancement, struct SDL_Rect * positionSnake)
{
        switch(direction)
        {
    case UP:    positionSnake->y -= avancement; break;
        case DOWN:      positionSnake->y += avancement; break;
        case LEFT:      positionSnake->x -= avancement; break;
        case RIGHT:     positionSnake->x += avancement; break;
    }
}

/* DEBUT MAIN() */

int main(int argc, char *argv[])
{
    /* Déclaration du fichier HighScore qui contiendra les meilleurs scores */
FILE * HighScore = NULL;

        /* Déclaration des variables "primitives" (compteurs généralement) */
int continuer = 1,
    avancementHauteur = 0,
        avancementLargeur = 0,
    tempsDebut = 0,
    tempsFin = 0,
    tempsEcoule = 0,
    HAUTEUR_SNAKE = 0,
    LARGEUR_SNAKE = 0;
char sscore[200] = "";
enum direction direction;
direction = RIGHT;
       
        /* La vidéo et le timer son initalisés */
if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER) == -1)
{
        fprintf(stderr, "Couldn't initialize SDL : %s\n", SDL_GetError());
        exit(EXIT_FAILURE);
}

        /* Lors de l'arrêt, SDL_Quit() s'éxecutera */
atexit(SDL_Quit);


        /* Initialisation de la librairie SDL_TTF */
if (TTF_Init() < 0)
{
        printf("Could'nt initialize TTF Library. Exiting.\n");
        exit(EXIT_FAILURE);
}

TTF_Font *policeTexte = TTF_OpenFont("./Vera.ttf", 12);

if(!policeTexte)
{
        printf("Couldn't initialize TTF Font");
        return EXIT_SUCCESS;
}

atexit(TTF_Quit);

        /* Déclaration des surfaces SDL et position */
SDL_Event event;
SDL_Surface *ecran = NULL,
                        *snake[MAX_ENNEMIS+1] = {NULL},
                        *proie = NULL,
                        *bonus = NULL,
                        *surfaceTexte = NULL;
SDL_Rect positionSnake[MAX_ENNEMIS+1], positionProie, positionTexte, positionBonus;
SDL_Color couleurTexte;

couleurTexte.r = 255;
couleurTexte.g = 0;
couleurTexte.b = 0;

        /* Ouverture d'un mode vidéo en 32 bits - chargement matériel, double
        buffering, mise à niveau du format si le 32 bits n'est pas supporté */
ecran = SDL_SetVideoMode(L_FENETRE, H_FENETRE, 32, SDL_HWSURFACE|SDL_DOUBLEBUF|SDL_ANYFORMAT);

        /* Vérification de l'ouverture du mode vidéo */
if (ecran == NULL)
{
        fprintf(stderr, "Couldn't set Video Mode : %s\n", SDL_GetError());
        return EXIT_FAILURE;
}

        /* Titre de la fenêtre */
SDL_WM_SetCaption("Snake", NULL);

        /* Initialisation des personnages */
for(i = 0; i <= (MAX_ENNEMIS - 1); i++)
{
snake[i] = SDL_LoadBMP("./snake.bmp");
positionSnake[i].x = ecran->w / 2 - snake[i]->w / 2;
positionSnake[i].y = ecran->h / 2 - snake[i]->h / 2;
        if (snake[i] == NULL)
    {
        fprintf(stderr, "Couldn't load snake.bmp at %d iteration : %s\n", i, SDL_GetError());
        return EXIT_FAILURE;
        }
}

LARGEUR_SNAKE = snake[0]->w;
HAUTEUR_SNAKE = snake[0]->h;
avancementLargeur = LARGEUR_SNAKE / 2;
avancementHauteur = HAUTEUR_SNAKE / 2;

        /* Chargement de l'image de la proie */
proie = SDL_LoadBMP("./proie.bmp");
if (proie == NULL)
{
        fprintf(stderr, "Couldn't load proie.bmp : %s\n", SDL_GetError());
        return EXIT_FAILURE;
}

        /* Chargement de l'image du bonus */
bonus = SDL_LoadBMP("./bonus.bmp");
if (bonus == NULL)
{
        fprintf(stderr, "Couldn't load bonus.bmp : %s\n", SDL_GetError());
        return EXIT_FAILURE;
}

        /* Gestion de la transparence de la proie */
SDL_SetColorKey(proie, SDL_SRCCOLORKEY, SDL_MapRGB(proie->format, 255, 0, 0));
SDL_SetColorKey(bonus, SDL_SRCCOLORKEY, SDL_MapRGB(bonus->format, 255, 0, 0));

        /* Positionnement aléatoire de la proie */
if (positionnerProie(&positionProie) != 1)
{
        fprintf(stderr, "positionnerProie() incorrectly loaded");
}

        /* Positionnement aléatoire du bonus */
if (positionnerProie(&positionBonus) != 1)
{
        fprintf(stderr, "positionnerProie() incorrectly loaded");
}

    /* Démarrage du compteur temporel */
tempsDebut = SDL_GetTicks();

        /* DEBUT BOUCLE PRINCIPALE */
while (continuer && (ennemisBouffes < MAX_ENNEMIS))
{

/* Attente d'un évènement */
SDL_PollEvent(&event);
       
switch(event.type) /* Gestion des évènements */
{
case SDL_QUIT: continuer = 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_LEFT:  if(direction != RIGHT)
                                                direction = LEFT;
                                            break;
         case SDLK_RIGHT: if(direction != LEFT)
                                                direction = RIGHT;
                                            break;
     case SDLK_ESCAPE:  continuer = 0; break;
     } break;
}

        typeProie = PROIE;
        approxVerif(&positionProie, &positionSnake[0], typeProie);

        if((ennemisBouffes-1) % 5 == 0 && ennemisBouffes-1 != 0)
        {
                typeProie = BONUS;
                approxVerif(&positionBonus, &positionSnake[0], typeProie);
        }

        /* Chaque personnage prend la position de celui qui le précéde */
        for(i = ennemisBouffes; i >= 1; i--)
        {
        positionSnake[i].x = positionSnake[i-1].x;
        positionSnake[i].y = positionSnake[i-1].y;
        }
       
       
        /* On bouge le premier personnage dans la direction qui convient, les autres suivront. */
    if(direction == UP || direction == DOWN)
                move(direction, avancementHauteur, &positionSnake[0]);
        else
                move(direction, avancementLargeur, &positionSnake[0]);
     
        /* Si la tête touche le corps, la boucle se termine */
        for(i = 1; i<=ennemisBouffes; i++)
        {
                if(     positionSnake[0].x == positionSnake[i].x &&
                        positionSnake[0].y == positionSnake[i].y )
                {
                        continuer = 0;
                }
        }
       
        /* Si la tête (ou autre partie) sort de l'écran, il réapparait de l'autre côté */
        for(i = 0; i<=ennemisBouffes; i++)
        {
                switch(positionSnake[i].x)
                {
                        case 0:                 positionSnake[i].x = L_FENETRE - LARGEUR_SNAKE; break;
                        case L_FENETRE: positionSnake[i].x = 0 + LARGEUR_SNAKE; break;       
                }
               
                switch(positionSnake[i].y)
                {
                        case 0:   positionSnake[i].y = H_FENETRE - HAUTEUR_SNAKE; break;
                        case H_FENETRE: positionSnake[i].y = 0 + HAUTEUR_SNAKE; break;
                }
        }

/* Actualisation de la chaîne "sscore" */
sprintf(sscore, "Score : %d", score, ennemisBouffes-1);
       
/* Effaçage de l'écran */
SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 127, 227, 165));   
       
/* Blit du texte */
surfaceTexte = TTF_RenderText_Solid(policeTexte, sscore, couleurTexte);
positionTexte.x = L_FENETRE - surfaceTexte->w;
positionTexte.y = H_FENETRE - surfaceTexte->h;
SDL_BlitSurface(surfaceTexte, NULL, ecran, &positionTexte);
       
/* Blit de la proie */
SDL_BlitSurface(proie, NULL, ecran, &positionProie);
       
/* On blitte les serpents un par un */
for(i = 0; i <= ennemisBouffes; i++)
{
        SDL_BlitSurface(snake[i], NULL, ecran, &positionSnake[i]);
}

/* Blit du bonus si bonus il y a */
if((ennemisBouffes-1) % 5 == 0 && ennemisBouffes-1 != 0)
{
        SDL_BlitSurface(bonus, NULL, ecran, &positionBonus);
}

/* Switch des buffers (écrans) */
SDL_Flip(ecran);
}
/* FIN BOUCLE PRINCIPALE */

/* Calcul du temps écoulé */
tempsFin = SDL_GetTicks();
tempsEcoule = (tempsFin - tempsDebut) / 1000;

/* Libération des surfaces */
SDL_FreeSurface(surfaceTexte);
TTF_CloseFont(policeTexte);
SDL_FreeSurface(proie);
        for (i=0; i<=MAX_ENNEMIS; i++)
        {
SDL_FreeSurface(snake[i]);
        }
       
TTF_Quit();
SDL_Quit();

HighScore = fopen("highscore.txt", "a+");
if (HighScore == NULL)
{
              printf("highscore.txt n'a pu être ouvert");
              return EXIT_FAILURE;
}
fprintf(HighScore, "Score : %d points -- Temps : %d s", score, tempsEcoule);
fclose(HighScore);

return EXIT_SUCCESS;
}