SDL: Faire apparaître plusieurs voiture à la suite

/*
 * TAXIS    Une démo d'implémentation d'un système de gestion 
 *          d'objets animés en SDL, ayant des vitesses relatives 
 *          différentes et gestion de la visibilité sur la 
 *          fenêtre d'affichage        
 *
 * Version: @(#)taxis.c 1.0     29/11/2016
 *
 * Auteur:  [Dal] sur le forum de Commentcamarche.net
 *          http://www.commentcamarche.net/forum/affich-34091100#14
 *
 *      Licence Creative Commons by-nc-sa 3.0
 *      https://creativecommons.org/licenses/by-nc-sa/3.0/fr/
 *      Attribution avec le lien précité sur le forum
 */
#include <stdlib.h>
#include <stdio.h>
#include <SDL/SDL.h>
#include <SDL/SDL_image.h>
#include <time.h>

/* constantes */
#define LARGEUR_FENETRE 640
#define HAUTEUR_FENETRE 480
#define VITESSE_INIT_VOIT 5
#define VITESSE_MAX_VOIT 10
#define VITESSE_MIN_VOIT 2
#define VITESSE_TAXI 4
#define VITESSE_JEU 10
#define NB_VOIES 3
#define LARG_TAXI 71
#define LONG_TAXI 78
#define ESPACE_TAXI (LONG_TAXI + (LONG_TAXI / 2))
#define MI_HAUTEUR_FENETRE (HAUTEUR_FENETRE / 2)

#define MAX_TAXIS   30  /* max taxis */

enum action {
    DROITE, /* pour changer de file */
    GAUCHE, /* pour changer de file */
    BAS,    /* pour ralentir */
    HAUT,   /* pour accélérer */
    RIEN    /* aucune touche pressée */
};

struct car {
    int vitesse;
    unsigned int y;     /* position y dans le monde, au départ
                           on place la voiture à l'origine 0 */
    enum action act;
};

struct taxi {
    int voie;
    unsigned int y;     /* position y dans le monde, 0 est le début de
                           la route */
    SDL_Rect coord;     /* coordonnées calculées à l'écran, si le taxi
                           est visible */
    int vitesse;
    int visible;
};

struct game {
    int loop;   /* continue loop or not */
    int score;
    int cur_time;
    int prev_time;
    int xvoies[NB_VOIES];   /* x coord pour chaque voie */
};

void init_objects(struct game * game, struct car * car, struct taxi taxis[]);
void move_objects(struct game * game, struct car * car, struct taxi taxis[]);
void get_input(struct car * car, int * continue_game);
void render(SDL_Surface *ecran, SDL_Surface *taxi, struct taxi taxis[]);

int main(int argc, char* args[]) {
    SDL_Surface *ecran = NULL;
    SDL_Surface *taxi = NULL;

    if (SDL_Init(SDL_INIT_VIDEO) == -1) {
        fprintf(stderr, "Erreur d'initialisation de la SDL");
        exit(EXIT_FAILURE);
    }
    ecran = SDL_SetVideoMode(LARGEUR_FENETRE, HAUTEUR_FENETRE, 32, SDL_HWSURFACE | SDL_DOUBLEBUF | SDL_INIT_TIMER);
    if (ecran == NULL ) {
        fprintf(stderr, "Impossible de charger le mode vidéo : %s\n", SDL_GetError());
        exit(EXIT_FAILURE);
    }
    taxi = IMG_Load("taxi.png");

    struct car car;
    struct taxi taxis[MAX_TAXIS];
    struct game game;

    init_objects(&game, &car, taxis);

    while (game.loop) {
        game.cur_time = SDL_GetTicks();
        get_input(&car, &game.loop);
        if (game.cur_time - game.prev_time > VITESSE_JEU) {
            game.prev_time = game.cur_time;
            move_objects(&game, &car, taxis);
            render(ecran, taxi, taxis);
        } else {
            SDL_Delay(VITESSE_JEU - (game.cur_time - game.prev_time));
        }
    }
    
    /* libérer tout et fermer */
    SDL_FreeSurface(taxi);
    SDL_Quit();

    return 0;
}

void init_objects(struct game * game, struct car * car, struct taxi taxis[]) {
    int n;
    /* rand */
    srand(time(NULL));
    /* game data */
    game->loop = 1;
    game->score = 0;
    game->cur_time = 0;
    game->prev_time = 0;
    /* positions horizontales par voies */
    for (n=0; n<NB_VOIES; n++)
        game->xvoies[n] = (LARGEUR_FENETRE / NB_VOIES / 2) 
            + ((LARGEUR_FENETRE / NB_VOIES) * n)
            - (LARG_TAXI / 2);
    /* init car */
    car->vitesse = VITESSE_INIT_VOIT;
    car->y = 0;
    car->act = RIEN;    
    /* init taxis */
    for (n=0; n<MAX_TAXIS; n++) {
        taxis[n].voie = rand() % NB_VOIES;
        taxis[n].y = ESPACE_TAXI * (n + 1);
        taxis[n].vitesse = VITESSE_TAXI;
        taxis[n].visible = 0;
        taxis[n].coord.w = LARG_TAXI;
        taxis[n].coord.h = LONG_TAXI;
    }
}

void move_objects(struct game * game, struct car * car, struct taxi taxis[]) {
    int n;
    int finished = 1;

    /* car */
    if (car->act == HAUT && car->vitesse < VITESSE_MAX_VOIT) {
        car->vitesse++;
    }
    if (car->act == BAS && car->vitesse > VITESSE_MIN_VOIT) {
        car->vitesse--;
    }
    car->y += car->vitesse;
    car->act = RIEN;
    /* taxis */
    for (n=0; n<MAX_TAXIS; n++) {
        /* décider, en fonction de la distance parcourue par la voiture
         * les coordonnées du taxi, et la dimension de l'écran graphique
         * si ce taxi est visible ou pas, et précalculer sa position
         * à l'écran s'il doit l'être */
        taxis[n].y += taxis[n].vitesse;
        if (abs(taxis[n].y - car->y) < MI_HAUTEUR_FENETRE) {
            taxis[n].visible = 1;
            taxis[n].coord.x = game->xvoies[taxis[n].voie];
            taxis[n].coord.y = MI_HAUTEUR_FENETRE - (taxis[n].y - car->y);
            finished = 0;
        } else
            taxis[n].visible = 0;
    }
    if (finished)
        game->loop = 0;
}

void get_input(struct car * car, int * continue_game){
    SDL_Event event;

    while (SDL_PollEvent(&event)) {  
        // Si il y'a un évènement SDL, on le traite
        switch(event.type) {
            case SDL_QUIT:
                *continue_game = 0;
                break;
            case SDL_KEYDOWN :
                switch(event.key.keysym.sym) {
                    case SDLK_ESCAPE: // Appui sur la touche Echap, on arrête le programme
                        *continue_game = 0;
                        break;
                    case SDLK_UP : // Flèche haut
                        car->act = HAUT;
                        break;
                    case SDLK_DOWN : // Flèche bas
                        car->act = BAS;
                        break;
                    case SDLK_RIGHT : // Flèche droite
                        car->act = DROITE;
                        break;
                    case SDLK_LEFT : // Flèche gauche
                        car->act = GAUCHE;
                        break;
                    default :
                        car->act = RIEN;
                        break;
                }
            default :
                break;
        }
    }
}

void render(SDL_Surface *ecran, SDL_Surface *taxi, struct taxi taxis[]){
    int n;

    /* clear everything */
    SDL_FillRect(ecran, 0, 0);
    /* draw taxis */
    for (n=0; n<MAX_TAXIS; n++) {
        if (taxis[n].visible)
            SDL_BlitSurface(taxi, NULL, ecran, &taxis[n].coord);
    }
    /* draw car, etc. */
    // TODO
    SDL_Flip(ecran);
}

#include <stdlib.h>
#include <stdio.h>
#include <SDL/SDL.h>
#include <SDL/SDL_image.h>
#include <time.h>
#include <SDL/SDL_ttf.h>
#include <string.h>
//header perso
#include "constantes.h"
#include "affichage_taxi.h"
#include "traitement.h"

void automatique(SDL_Surface *ecran, int continue1);
int valeur_random(int valeur);


//Main fonction
int main(int argc, char *argv[])
{
 SDL_Surface *ecran = NULL, *ecran1 = NULL;
 //int continue1 = 1;
 int continue2 = 1;

 automatique(ecran, continue2);
 SDL_Quit();

 return EXIT_SUCCESS;
}



void automatique(SDL_Surface *ecran, int continue1){
 //initialisation des variables
 SDL_Surface *car = NULL, *taxi = NULL, *map=NULL, *taxi2 = NULL, *taxi3 = NULL, *map2=NULL, *texte1=NULL;
 SDL_Rect positionCar, positionTaxi, positionTaxi2, positionTaxi3, positionMap, positionMap2, positiontxt1;

 Car Car;
 Taxi Taxi;
 Taxi2 Taxi2;
 Taxi3 Taxi3;
 SDL_Event event;
 SDL_Rect position;
 SDL_Color couleurNoire = {0,0,0};

 TTF_Font *police = NULL;
 int a = 0;
 int X=-533;
 char temps2[20] = "";
 int compteur = 0;
 int tempsPrecedent = 0, tempsActuel;
 int choix_alea;
 int A, B, C, k;
 int Y=0;
 int continuer = 1;

 TTF_Init();

 // Initialisation du générateur de nombre aléatoires
 srand(time(NULL)); 

 // Initialisation de SDL avec Gestion d'erreurs
 if (SDL_Init(SDL_INIT_VIDEO) == -1)
 {
  fprintf(stderr, "Erreur d'initialisation de la SDL");
  exit(EXIT_FAILURE);
 }


 // Chargement de l'icône de la barre de fenêtre AVANT SDL_SetVideoMode
 SDL_WM_SetIcon(IMG_Load("images/route_finale2.png"), NULL);

 // initialisation de la fenêtre avec les constante défini dans le préprocesseur
 ecran = SDL_SetVideoMode(LARGEUR_FENETRE, HAUTEUR_FENETRE, 32, SDL_HWSURFACE | SDL_DOUBLEBUF);

 //petite vérification de la fenêtre
 if ( ecran == NULL )
 {
  fprintf(stderr, "Impossible de charger le mode vidéo : %s\n", SDL_GetError());
  exit(EXIT_FAILURE);
 }

 // On ajoute un titre
 SDL_WM_SetCaption("Gestion du temps en SDL", NULL);

 // on charge la route_finale2
 map = IMG_Load("images/route_finale1.png");
 map2 = IMG_Load("images/route_finale2.png");

 // on fixe la position
 positionMap2.x = 0;
 positionMap2.y = X;
 // on fixe la position
 positionMap.x = 0;
 positionMap.y = Y;

 // on charge car
 car =  IMG_Load("images/car.png");

 // position par défaut de car
 Car.positionx_Car = 190;
 Car.positiony_Car = 400;

 // taille car
 Car.taillex_Car = car->w;
 Car.tailley_Car = car->h;

 // on configure l'affichage de car
 SDL_SetColorKey(car, SDL_SRCCOLORKEY, SDL_MapRGB(car->format, 0, 0, 255));

 // on charge le taxi
 taxi = IMG_Load("images/taxi.png");
 taxi2 = IMG_Load("images/taxi.png");
 taxi3 = IMG_Load("images/taxi.png");

 /* Chargement de la police */
 police = TTF_OpenFont("fonts/OptimusPrincepsSemiBold.ttf", 30);

 //Position texte1
 positiontxt1.x=2;
 positiontxt1.y=10;

 // Déclaration de la variable temps_sec_ecoule
 int temps_sec_ecoule;
 temps_sec_ecoule=SDL_GetTicks()/1000; // Conversion du temps en seconde
 compteur=temps_sec_ecoule;


 while(continue1)

 {

  while (SDL_PollEvent(&event)) // correct
  {  
   // Si il y'a un évènement SDL, on le traite
   switch(event.type)
   {
    case SDL_QUIT:
     continue1 = 0;
     break;
    case SDL_KEYDOWN :
     switch(event.key.keysym.sym)
     {
      case SDLK_ESCAPE: // Appui sur la touche Echap, on arrête le programme
       continue1 = 0;
       // menu(ecran3,  continue3);
       break;
     }
     break;
   }

  }

  sprintf(temps2, "Appuyez sur ECHAP pour quitter");
  texte1 = TTF_RenderText_Blended(police, temps2, couleurNoire);



  choix_alea = valeur_random(k);
  switch(choix_alea)
  {
   case 85:
    A=-170;
    Taxi.positionx_Taxi = 85;
    if (Taxi.positiony_Taxi>533)
    {
     Taxi.positiony_Taxi=A;
    }
    else
    {
     Taxi.positiony_Taxi=Taxi.positiony_Taxi+1;
    }
    break;
   case 190:

    if (choix_alea == 190)
    {
     Taxi2.positionx_Taxi2 = 190;
     B=-170;
     if (Taxi2.positiony_Taxi2>533)
     {
      Taxi2.positiony_Taxi2=B;
     }
     else
     {
      Taxi2.positiony_Taxi2=Taxi2.positiony_Taxi2+1;
     }
    }

    break;
   case 295:

    if (choix_alea == 295)
    {
     Taxi3.positionx_Taxi3 = 295;
     C=-170;
     if (Taxi3.positiony_Taxi3>533)
     {
      Taxi3.positiony_Taxi3=C;
     }
     else
     {
      Taxi3.positiony_Taxi3=Taxi3.positiony_Taxi3+1;
     }
    }

    break;
  }

  Y = Y+2;
  positionMap.y = Y;
  positionMap2.y = X;
  if (positionMap.y = Y)
  {
   X=X+2;
  }
  if (positionMap.y > 533)
  { 
   X=-533;
   positionMap.y=X;
   Y=0;
   positionMap2.y=Y;
  }

  tempsActuel = SDL_GetTicks();
  if (tempsActuel - tempsPrecedent > VITESSE) // Si 30 ms se sont écoulées depuis le dernier test
  {
   tempsPrecedent=tempsActuel;
  }

  else // Si ça fait moins de 30ms depuis le dernier tour de boucle, on endort le programme le temps qu'il faut
  {
   SDL_Delay(VITESSE - (tempsActuel - tempsPrecedent));
  }



  //report des coordonées
  positionCar.x = Car.positionx_Car;
  positionCar.y = Car.positiony_Car;

  positionTaxi.x = Taxi.positionx_Taxi;
  positionTaxi.y = Taxi.positiony_Taxi;

  positionTaxi2.x = Taxi2.positionx_Taxi2;
  positionTaxi2.y = Taxi2.positiony_Taxi2;

  positionTaxi3.x = Taxi3.positionx_Taxi3;
  positionTaxi3.y = Taxi3.positiony_Taxi3;

  // on refait l'affichage avec les nouveau paramêtres
  SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 255, 255, 255));
  SDL_BlitSurface(map2, NULL, ecran, &positionMap2);
  SDL_BlitSurface(map, NULL, ecran, &positionMap);
  //SDL_BlitSurface(taxi, NULL, ecran, &positionTaxi);
  SDL_BlitSurface(taxi2, NULL, ecran, &positionTaxi2);
  SDL_BlitSurface(taxi3, NULL, ecran, &positionTaxi3);
  SDL_BlitSurface(car, NULL, ecran, &positionCar);
  SDL_BlitSurface(texte1, NULL, ecran, &positiontxt1); 
  SDL_Flip(ecran);
 }

 SDL_FreeSurface(texte1);
 SDL_FreeSurface(map);
 SDL_FreeSurface(map2);
 SDL_FreeSurface(car);
 SDL_FreeSurface(taxi);
 SDL_FreeSurface(taxi2);
 SDL_FreeSurface(taxi3);
 SDL_FreeSurface(ecran);
 TTF_CloseFont(police);
 TTF_Quit();
 // Fermeture de sdl et fin
}

int valeur_random(int valeur){

 srand(time(NULL));
 const int MIN = 0, MAX = 2;
 int nombre_aleatoire = 0;

 // Nombre compris entre 0 à 3
 nombre_aleatoire = (rand() % (MAX + 1 - MIN)) + MIN;
 valeur = nombre_aleatoire*105 + 85;
 // Position d'apparition du Taxi
 return valeur;
}