[C][SDL]Exécuter deux fonctions en même temps

[InFamouZz]

Salut a tous,
Je travail depuis un bon moment sur un projet SDL ( création d'un jeux video de course en 2D type taxidriver ... ) Mais je suis bloqué a un point qui est très peux évoqué en SDL.

En effet j'ai coder deux fonction :
- une fonction "tombe" qui fais apparaitre des voitures ( en blitants et libérant au fur et a mesure ) du haut de l'écran jusqu'en bas

- une fonction "changement" qui vas changer la voie de circulation de la voiture du joueur ( en blitants et libérant au fur et a mesure comme avant jusqu'a arriver a la bonne voie en fonction de la saisie de l'utilisateur).

Mais mon problème est d'exécuter ses deux fonction en même temps, après m'être renseigner j'ai entendu parler de THEARD mais je ne sais pas comment elle marche, n'y ou en trouver une document ( pas trop complexe ^^ )

[Hypnoze57]

Je crois qu'openMP permet le multi threading (bien que je n'en ai jamais fais)

[gruik]

salut InFamouZz,

(...) jeux video de course en 2D type taxidriver (...)

le seul Taxi Driver que je connais c'est celui avec De Niro, t'as des photos ?

En effet j'ai coder deux fonction (...) une qui fais apparaitre des voitures (...) une qui vas changer la voie de circulation de la voiture du joueur (...) mon problème est d'exécuter ses deux fonction en même temps

vu d'ici les threads ne sont pas la solution, il te faut penser/tourner ton code différement, c'est pas "la route défile et y'a plusieurs actions en simultané", c'est plutôt "qu'est-ce que j'affiche à chaque image"

[InFamouZz]

j'avais pensé à ça mais le problème est que dans mes deux fonctions ce sont des boucles qui affichage et libère donc quand tu exécute une des deux fonctions tu est obliger d'attendre que sa boucle soit finie pour pour pouvoir exécuter l'autre fonction , et je ne vois pas de moyen sans threads de le faire.
De plus notre prof nous avais dis de regarder les threads pour ce projet.

[Sh4dows]

Il me semblait que la SDL embarquait un système de threading.. Tu as fais le tour des fonctions disponible ? Certaines pourraient "peut être" t'aider à faire ce que tu veux.

Sinon tu peux utiliser les timers à gogo
Si tu veux quand même du threading, pthreads est pas mal (nux).

[gruik]

je ne vois pas de moyen sans threads de le faire.

sur le principe c'est la différence entre ça :

Code C :

#include <stdio.h>
#include <unistd.h>

void fais_tout (void) {
        char *texte[] = {"hel", "lo ", "wor", "ld ", "!\n"};
        int toto;
        for (toto = 0; toto < 5; toto++) {
                sleep(1);
                printf ("%s", texte[toto]);
        }
}

int main (void) {
       
        fais_tout();
        return 0;
}

et ça :

Code C :

#include <stdio.h>
#include <unistd.h>

#define ACT_AFFICHEMSG  1
#define ACT_WAIT        2

void fais_un_truc (int action, int i) {
        char *texte[] = {"hel", "lo ", "wor", "ld ", "!\n"};
        switch(action) {
                case 1: { /* i est la partie du message a afficher */
                        printf ("%s", texte[i]);
                        break;
                }
                case 2: { /* i est le nombre de secondes a attendre */
                        Sleep(i);
                        break;
                }
                default: return;
        }
}

int main (void) {
        int toto;
        for (toto = 0; toto < 5; toto++) {
                fais_un_truc (ACT_WAIT, 1);
                fais_un_truc (ACT_AFFICHEMSG, toto);
        }
        return 0;
}

au delà du fait qu'on a une même fonction qui sert de dispatcher pour les différentes actions (switch/case) l'intérêt c'est surtout que dans le 2e code on garde la main sur la boucle toto, du coup on appelle la fonction en lui passant juste la partie du message à afficher, c'est un peu comme appeler une fonction film() en lui donnant comme paramètre l'image à afficher

De plus notre prof nous avais dis de regarder les threads pour ce projet.

c'est possible mais il ne devait pas parler de mettre plusieurs threads qui bossent en même temps sur la même ressource (la surface principale/l'écran), ce n'est ni la bonne façon de faire ni une bonne idée

[sakiir]

Si c'est sous windows tu peux utiliser la fonction CreateThread()
Si non renseigne toi sur la "libpthread" qui peut être utilisé aussi bien sur windows ue sur un autre OS !

[InFamouZz]

merci pour les réponses.
@ gruik : je pense que si, tu ne peux pas boucler sur deux boucles en même temps surtout quand elle se déclenche a des moments différent et indéterminé. c obliger de faire du multitâche...

[InFamouZz]

concrètement le problème est :
ndgruik: je me suis permis de réindenter le code et rajouter la balise [code]

Code C :

while (continuer!=0) {
        SDL_PollEvent(&event);
        switch(event.type) {
                case SDL_QUIT:
                        continuer = 0;
                        break;
                case SDLK_ESCAPE :
                        Continuer = 0;
                        break;
                case SDL_KEYDOWN :
                        switch(event.key.keysym.sym) {
                                case SDLK_RIGHT :
                                        droite();
                                        break;
                                case SDLK_LEFT :
                                        gauche();
                                        break;
                                default:
                                        break;
                        }
                        break;
        }

        tempsActuel = SDL_GetTicks();
        if (tempsActuel - tempsPrecedent > 30){
                descente();
        }
}

je voudrais pouvoir exécuter la fonction gauche ou droite sans attendre que descente est finie

[balis]

Look la biblio pthread.h qui est fun. J'ai bossé dessus quelques temps et j'ai trouvé que c'était pratique.

[gruik]

je voudrais pouvoir exécuter la fonction gauche ou droite sans attendre que descente est finie

j'avais bien compris, le but c'est de modifier ta boucle de cette façon (en gros, pas testé):

Code DIFF :

--- original    2013-12-28 02:20:29.991113200 +0100
+++ modified    2013-12-28 02:20:30.069113300 +0100
@@ -7,13 +7,15 @@
                case SDLK_ESCAPE :
                        Continuer = 0;
                        break;
+               case SDL_KEYUP:
+                       compteur_animation = 0;
                case SDL_KEYDOWN :
                        switch(event.key.keysym.sym) {
                                case SDLK_RIGHT :
-                                       droite();
+                                       droite(compteur_animation++);
                                        break;
                                case SDLK_LEFT :
-                                       gauche();
+                                       gauche(compteur_animation++);
                                        break;
                                default:
                                        break;

et forcément il faut répercuter la modification dans tes fonctions droite() et gauche() du coup, elles ne peuvent plus (ne doivent plus !) tout faire d'une traite dans une boucle mais au contraire s'adapter a la valeur de compteur_animation
“A computer is a state machine. Threads are for people who cant program state machines.” (Alan Cox)

après tu peux toujours t'entêter sur une approche par threads comme je vois que tout le monde y va de son lien bien senti mais je le répète ça revient à coder n'importe comment

[b0fh]

Je plussoie gruik, les pthreads ne sont absolument pas adaptés à la situation. Ce ne sont pas vraiment deux activités concurrentes puisqu'elle se partagent complètement un état (celui du jeu), tu as donc le choix entre tout protéger avec un gros mutex (et avoir des performances inutilement pires qu'avec un code sans threads) ou une protection bancale qui pourra altérer le gameplay (l'OS décide aléatoirement de bloquer le thread d'input sans bloquer les autres threads du jeu, c'est affreusement frustrant pour le joueur).

Une meilleure solution serait d'utiliser des coroutines mais C ne les supportant pas, il va falloir les faire à la main, en écrivant une seule boucle qui traitera les deux cas à chaque itération, en sauvegardant si nécessaire la situation actuelle dans des variables, au lieu de se baser sur le flot de contrôle pour exécuter des actions succesives.

[sakiir]

perso j'ai pas fais attention à la situation , mais vu le titre j'ai vu que ça comme solution :p