La gestion du temps dans la SDL

Bonjour,

J'ai mis le déplacement du personnage dans la condition mais je n'ai pas bien compris si la fonction

SDL_GetTicks()

influence uniquement le déplacement du personnage dans cette même condition ou si elle influence tout le code ? par exemple est ce ça qui déterminera le nombre de FPS de l'ensemble du code ? si j'introduisais d'autres personnages, est ce qu'il faudrait créer d'autres conditions avec

SDL_GetTicks()

ou faut il mieux utiliser des timers comme tu en as parler précédemment ?
J'ai essayé ce que tu as dit pour le déplacement en retard du viseur mais le décalage est toujours là (si j'ai bien fait)

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

#include "constante.h"

char* table[] = {
"000000000000000",
"000000000000000",
"000000000000000",
"000000000000000",
"000000000000000",
"000000000000000",
"000000000000000",
"100000000111110",
"000000000000000",
"000000000000000",
"000000000000000",
"003400022220022",
"005600000000000",
"005600000000000",
"005600000000000",
"777777777777777"};

int setWindowColor(SDL_Renderer *afficheur, SDL_Color color)
{
    if (SDL_SetRenderDrawColor(afficheur, color.r, color.g, color.b, color.a) < 0)
        return -1;
    if (SDL_RenderClear(afficheur) < 0)
        return -1;
    return 0;
}

void Afficher(SDL_Renderer* afficheur, SDL_Texture* textuTil,
              char** table, int nombre_blocs_largeur, int nombre_blocs_hauteur)
{
	int i, j;
	SDL_Rect Rect_dest;
	SDL_Rect Rect_source;
	Rect_source.w = LARGEUR_TILE;
	Rect_dest.w   = LARGEUR_TILE;
	Rect_source.h = HAUTEUR_TILE;
	Rect_dest.h   = HAUTEUR_TILE;
	for(i = 0 ; i < nombre_blocs_largeur ; i++)
	{
		for(j = 0 ; j < nombre_blocs_hauteur ; j++)
		{
			Rect_dest.x = i * LARGEUR_TILE;
			Rect_dest.y = j * HAUTEUR_TILE;
			Rect_source.x = (table[j][i] - '0') * LARGEUR_TILE;
			Rect_source.y = 0;
            SDL_RenderCopy(afficheur, textuTil, &Rect_source, &Rect_dest);
		}
	}
}

int main(int argc, char *argv[])
{
    SDL_Window *ecran = NULL;
    SDL_Renderer *afficheur = NULL;
    SDL_Surface *tileset = NULL, *image = NULL;
    SDL_Surface *imageActu = NULL, *viseur = NULL;
    SDL_Texture *texture, *textuViseur, *textuTil;

    SDL_Rect destHomer = {50, 50, 60, 90};
    SDL_Rect destViseur = {100, 100, 30, 30};

    SDL_Color orange = {255, 127, 40, 255};
    SDL_Event event;

    int continuer = 1, tempsActuel = 0, tempsPrecedent = 0, versLaDroite = 1;
    int statut = EXIT_FAILURE;


    if (SDL_Init(SDL_INIT_VIDEO) != 0)
        {
            fprintf(stderr, "Erreur SDL_Init : %s", SDL_GetError());
            goto Quit;
        }

    ecran = SDL_CreateWindow("Kill Homer !", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
                             LARGEUR_TILE*NOMBRE_BLOCS_LARGEUR, HAUTEUR_TILE*NOMBRE_BLOCS_HAUTEUR, SDL_WINDOW_SHOWN);
    if (ecran == NULL)
        {
            fprintf(stderr, "Erreur SDL_CreateTextureFromSurface : %s", SDL_GetError());
            goto Quit;
        }

    afficheur = SDL_CreateRenderer(ecran, -1, SDL_RENDERER_ACCELERATED);
    if (afficheur == NULL)
        {
            fprintf(stderr, "Erreur SDL_CreateRenderer : %s", SDL_GetError());
            goto Quit;
        }

    image = IMG_Load("homer.png");
    if (image == NULL)
        {
            fprintf(stderr, "Erreur SDL_CreateTexture : %s", SDL_GetError());
            goto Quit;
        }

    tileset = IMG_Load("tileset2.bmp");
    if (tileset == NULL)
        {
            fprintf(stderr, "Erreur SDL_CreateTexture : %s", SDL_GetError());
            goto Quit;
        }

    texture = SDL_CreateTextureFromSurface(afficheur, image);
    if (texture == NULL)
        {
            fprintf(stderr, "Erreur SDL_CreateTexture : %s", SDL_GetError());
            goto Quit;
        }

    viseur = IMG_Load("viseur.png");
    if (viseur == NULL)
        {
            fprintf(stderr, "Erreur SDL_CreateTexture viseur: %s", SDL_GetError());
            goto Quit;
        }


    textuViseur = SDL_CreateTextureFromSurface(afficheur, viseur);
    if (textuViseur == NULL)
        {
            fprintf(stderr, "Erreur SDL_CreateTexture viseur: %s", SDL_GetError());
            goto Quit;
        }

    textuTil = SDL_CreateTextureFromSurface(afficheur, tileset);
    if (textuTil == NULL)
        {
            fprintf(stderr, "Erreur SDL_CreateTexture sprite: %s", SDL_GetError());
            goto Quit;
        }

    SDL_FreeSurface(tileset);

    SDL_RenderClear(afficheur);

    setWindowColor(afficheur, orange);


    while(continuer)
    {
       while (SDL_PollEvent(&event))
        {
            switch(event.type)
            {
                case SDL_QUIT:
                    continuer = 0;
                    break;

                case SDL_MOUSEMOTION:
                    destViseur.x = event.motion.x - (viseur->w / 2);
                    destViseur.y = event.motion.y - (viseur->h / 2);
                    break;

                case SDL_KEYDOWN:
                    switch(event.key.keysym.sym)
                    {
                        case SDLK_ESCAPE:
                            continuer = 0;
                            break;
                    }
                    break;
            }
        }
    Afficher(afficheur, textuTil, table, NOMBRE_BLOCS_LARGEUR, NOMBRE_BLOCS_HAUTEUR);

    tempsActuel = SDL_GetTicks();

    if (tempsActuel - tempsPrecedent > 30)  /* si 30ms se sont écoulé depuis le dernier tour de la boucle
        plus le temps est petit plus il se deplace vite */
    {

        if (versLaDroite)
        {
            if (destHomer.x >= 790)
            {
                versLaDroite = 0;
            }
             else
             {
                 destHomer.x++;
             }
        }
        else
        {
            if (destHomer.x <= 0)
                {
                    versLaDroite = 1;
                }
            else
                {
                    destHomer.x--;
                }
        }
        tempsPrecedent = tempsActuel;  // le temps actuel devient le temps présent
    }
    else
    {
        SDL_Delay(30 - (tempsActuel - tempsPrecedent));
    }

    SDL_RenderCopy(afficheur, texture, NULL, &destHomer); // copie de image grâce au SDL_Renderer
    SDL_RenderCopy(afficheur, textuViseur, NULL, &destViseur);
    SDL_RenderPresent(afficheur); //  Affichage des textures

    }

    SDL_FreeSurface (image);
    SDL_FreeSurface (viseur);


    Quit:
        if (NULL != textuTil)
            SDL_DestroyTexture(textuTil);
        if(NULL != afficheur)
            SDL_DestroyRenderer(afficheur);
        if(NULL != ecran)
            SDL_DestroyWindow(ecran);
    SDL_Quit();
    return statut;
}