bonjour

je suis entrain de faire un jeu 2d en sdl.

je lis un fichier où dedans il y a les informations concernant l'affichage et aussi le temps d'attente entre les différents affichage (chaque temps d'attente et différent et il s'exprime en seconde).

donc dans mon programme je lis le fichier ligne par ligne avec les infos et à la fin de chaque tour de boucle, je fais un sdl_delay(1000 * nb_seconde)

le probleme c'est que tout le jeu est bloqué et je ne peux rien faire, alors que moi je veux que le jeu continue à tourner mais que mon programme attente nb_seconde avant de lire la ligne suivante dans le fichier

quelqu'un a une solution svp ?

Salut,

Est ce que tu peux nous mettre un bout de code ?

Hello,

L'alternative serait de faire quelque chose comme ça (en pseudo code) :

t_acces = mesure_temps()
while (...) {
  /* ... */
  t_courant = mesure_temps()
  if (t_courant - t_acces > nb_secondes){
    acceder_au_fichier()
    t_acces = t_courant
  }
  /* ... */
}

Bonjour,

Tu peux utiliser les timers ou faire une boucle principale qui tourne à période constante et tu comptes le nombre de tours de boucle pour faire les temporisations.

picosoft a écrit:

Bonjour,

Tu peux utiliser les timers ou faire une boucle principale qui tourne à période constante et tu comptes le nombre de tours de boucle pour faire les temporisations.

Désolé, mais c'est une idée absolument horrible de compter les tours de boucle pour temporiser. En général le temps d'exécution d'une boucle n'est pas constant, les facteurs suivant peuvent faire varier :

• Le flag de compilation. -O1, -O2 ou -O3 vont pas fournir les mêmes résultats -> il faudrait alors changer ta variable de tour de boucle à chaque fois que tu changes ton flag de compilation.
• Ton système d'exploitation. En particulier, si en fait ton processeur est utilisé en étant proche de 100% par d'autres programmes, ça va ralentir l'exécution de ton programme - ce qui va fausser complètement tes prédictions que tu avais faites en "tours de boucles"
• Niveau hardware, les processeurs type Intel ont un mécanisme du type "prédiction de branchement" qui peut faire varier d'une façon assez conséquente le temps d'exécution des boucles.

Si on fixe le flag d'optimisation et qu'on n'y touche plus, et si on est sur des architectures ultra prédictibles (ça existe), peut-être.. Mais dans le cadre d'un programmeur lambda qui code sur son x86 et son OS Windows/Linux/Mac, à éviter absolument.

Quite à compter quelque chose, autant se baser sur les fonctions de mesure de temps (la SDL en a) qui sont faites pour ça, par exemple SDL_GetTicks

https://wiki.libsdl.org/SDL_GetTicks

@Luzwitz : OK super

-
Edité par potterman28wxcv 13 mai 2019 à 17:53:19