/*
main.c

programme: scroll-vert
objectif : faire un scrolling vertical, genre "jeu de voiture"
date     : 22avr2006 jmb, sdz
*/

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

// Dimensions en sprite => taille de fenetre
#define TAILLE_SPRITE 12
#define NB_SPRITES_LARGEUR 30
#define NB_SPRITES_HAUTEUR 50


// Pour changer le profil de la route, on va choisir une valeur entre 0 et 100
// et faire un 0/+1/-1 sur la position des bords en fonction de cette valeur
#define ON_CHANGE_PAS  60  // entre 0 et 59, on change rien
#define PLUS_DIFFICILE 85  // de 61 à 84 la route va rétrécir
                           // de 85 à 99 la route va s'élargir

#define LARGEUR_MINI NB_SPRITES_LARGEUR/4    // Largeur minimale de la route

// Retourner un nombre choisi entre deux bornes
int pifometre(int mini, int maxi)
{
        return (rand() % (maxi-mini+1))+mini;
}

// Convertir une valeur entre 0 et 100 en 0, +1 ou -1 (variation de la route)
int estimerDecalage(int valeur)
{
    int resultat;

    if(valeur<ON_CHANGE_PAS)
        resultat=0;
    else if(valeur<PLUS_DIFFICILE)
        resultat=1;
    else
        resultat=-1;

    return resultat;
}

// Programme principal
int main(int argc, char *argv[])
{
    // Déclarations SDL standards
    SDL_Surface *ecran=NULL, *route=NULL, *bordure=NULL, *champ=NULL;
    SDL_Rect position;
    SDL_Event event;

    // Alias pour les sprites
    enum {ROUTE,BORDURE,CHAMP};

    // Tableau de pointeur de sprites pour simplifier le blittage
    SDL_Surface *ptrSurf[3];

    // Tableau 2D pour memoriser la route
    int piste[NB_SPRITES_HAUTEUR][NB_SPRITES_LARGEUR]={ROUTE};

    // Variables pour génération de la route
    int positionBordGauche=3;
    int positionBordDroit=NB_SPRITES_LARGEUR-6;

    // Variables diverses
    int ligneAGenerer=0;
    int indexLigneDuBas=0;
    int continuer=1;
    int i,j;

    // Initialisation de la SDL
    SDL_Init(SDL_INIT_VIDEO);

    // Chargement des sprites (SDL_LoadBMP...)
    route=SDL_CreateRGBSurface(SDL_HWSURFACE,TAILLE_SPRITE,TAILLE_SPRITE,32,0,0,0,0);
    bordure=SDL_CreateRGBSurface(SDL_HWSURFACE,TAILLE_SPRITE,TAILLE_SPRITE,32,0,0,0,0);
    champ=SDL_CreateRGBSurface(SDL_HWSURFACE,TAILLE_SPRITE,TAILLE_SPRITE,32,0,0,0,0);
    SDL_FillRect(route, NULL, SDL_MapRGB(route->format, 128, 128, 128));
    SDL_FillRect(bordure, NULL, SDL_MapRGB(bordure->format, 255, 128, 64));
    SDL_FillRect(champ, NULL, SDL_MapRGB(champ->format, 128, 255, 128));

    // Mise à jour du tableau de pointeur de sprites
    ptrSurf[ROUTE]=route;
    ptrSurf[BORDURE]=bordure;
    ptrSurf[CHAMP]=champ;

    // Démarrer le générateur pifométrique
    srand(time(NULL));

    // Ouverture de la fenêtre avec titre
    ecran=SDL_SetVideoMode(TAILLE_SPRITE*NB_SPRITES_LARGEUR, TAILLE_SPRITE*NB_SPRITES_HAUTEUR, 32, SDL_HWSURFACE | SDL_DOUBLEBUF);
    SDL_WM_SetCaption("Scrolling vertical",NULL);

    // Boucle principale (enfin !)
    while(continuer)
    {
        // Gestion des événements
        SDL_PollEvent(&event);
        switch(event.type)
        {
            case SDL_QUIT:
                continuer=0;
                break;

            case SDL_KEYDOWN:
                switch(event.key.keysym.sym)
                {
                    case SDLK_ESCAPE:
                        continuer=0;
                        break;
                }
                break;
        }

        // Générer une nouvelle ligne
        indexLigneDuBas++;
        if(indexLigneDuBas==NB_SPRITES_HAUTEUR)
            indexLigneDuBas=0;

        ligneAGenerer=indexLigneDuBas-1;
        if(ligneAGenerer<0)
            ligneAGenerer=NB_SPRITES_HAUTEUR-1;

        // Calcul décalage des bords
        positionBordGauche+=estimerDecalage(pifometre(0,100));
        positionBordDroit-=estimerDecalage(pifometre(0,100));

        // Ne pas défoncer les cotés gauche et droit
        if(positionBordGauche<0)
            positionBordGauche=0;

        if(positionBordDroit==NB_SPRITES_LARGEUR)
            positionBordDroit=NB_SPRITES_LARGEUR-1;

        // Ménager une largeur minimale pour la route LOGIQUE A VERIFIER
        if(positionBordDroit-positionBordGauche==LARGEUR_MINI-1)
            if(positionBordGauche<=1)
                positionBordDroit+=2;
            else
                positionBordGauche-=2;

        if(positionBordDroit-positionBordGauche==LARGEUR_MINI)
            if(positionBordGauche==0)
                positionBordDroit++;
            else
                positionBordGauche--;

        // Remplir la ligne
        for(i=0; i<NB_SPRITES_LARGEUR; i++)
        {
            if(i<positionBordGauche)
                piste[ligneAGenerer][i]=CHAMP;
            else if(i==positionBordGauche)
                piste[ligneAGenerer][i]=BORDURE;
            else if(i<positionBordDroit)
                piste[ligneAGenerer][i]=ROUTE;
            else if(i==positionBordDroit)
                piste[ligneAGenerer][i]=BORDURE;
            else
                piste[ligneAGenerer][i]=CHAMP;
        }

        // Blit-Time, Yeah !
        for(j=0; j<NB_SPRITES_HAUTEUR; j++)
        {
            if(j<indexLigneDuBas)
                position.y=(indexLigneDuBas-j-1)*TAILLE_SPRITE;
            else
                position.y=(NB_SPRITES_HAUTEUR+indexLigneDuBas-j-1)*TAILLE_SPRITE;

            for(i=0; i<NB_SPRITES_LARGEUR; i++)
            {
                position.x=i*TAILLE_SPRITE;
                SDL_BlitSurface(ptrSurf[piste[j][i]],NULL,ecran,&position);
            }
        }

        // Mise à jour de l'affichage
        SDL_Flip(ecran);
        sleep(50);
    }

    // Nettoyage de la place
    SDL_FreeSurface(ecran);
    SDL_FreeSurface(route);
    SDL_FreeSurface(bordure);
    SDL_FreeSurface(champ);
    SDL_FreeSurface(ptrSurf);
}

if (event.type == SDL_KEYDOWN && event.key.keysym.sym == SDLK_SPACE)
         {
             Sleep(5);
          for (i=0 ; i<50 ; i++) {
              rect1.y-=1;
              Sleep(10);
              SDL_BlitSurface(balle,NULL,screen,&rect1);     
                        }             
         for (i=0 ; i<50 ; i++) {
              rect1.y+=1;
              Sleep(10);
              SDL_BlitSurface(balle,NULL,screen,&rect1);
                        }             
         }