Discussion :

[Jordinateur]

Bonjour à tous

Je suis débutant et actuellement je travaille sur un petit projet qui a pour but de simuler de la pluie (oui oui, vous avez bien compris ) avec la SDL, qui peut-être un jour fera partit d'un petit moteur de RPG 2D ; d'ou la nécessité qu'il soit entièrement indépendant du fichier main pour qu'il s'execute en même temps que le jeu à proprement dit.

J'ai déjà réussi à générer les coordonnées des gouttes et déjà en tête comment les faires défiler ; seulement voilà :
J'apelle la fonction pluie à partir du fichier main.c
Je souhaite donc n'apeller qu'une seule fois la fonction pluie et qu'elle gère le reste toute seule, mais je souhaite EN MEME TEMPS, par exemple, déplacer un personnage par exemple.

Mais si je n'apelle la fonction qu'une seule fois, c'est impossible qu'elle fasses tout pendant que le joueur déplace le personnage (à moins que je n'ai pas vraiment compris comment sont lu mes fichiers) ; et même si je voulais appeller la fonction dans une boucle dans main cela ne changerais rien car une fois que la fonction est finie et qu'elle est réapellée dans la boucle les variables seront remises à 0 puisqu'elles le sont dans la fonction pluie (et je ne veux pas le faire ailleurs)

Alors je pourrais faire une boucle dans pluie qui déplacerais les gouttes de pluies mais JUSTEMENT je ne pourrais executer aucune action paralèlement.

Je ne sais pas si je me suis bien fait comprendre je vais tenter d'expliquer ceci avec les fichiers pour essayer de faire en sorte que ça soit vraiment clair.


Voici mon fichiers generation_goutte.c qui est la fonction pluie en fait :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
///=============================================================================
/*
generation_goute.c
 
-génération aléatoire d'une certaine quantité de gouttes
-génération aléatoire des coordonnées de toutes ces gouttes
-affichage des gouttes + simulation de pluie
-retournement à main.c des coordonnées de toutes les goutes dans un tableau de structure de coordonnées
*/
#include "generation_goute.h"
///=============================================================================
 
 
 
 
 
 
 
 
 
///=============================================================================
///DEBUT PLUIE
 
//Effet de pluie
void pluie (SDL_Surface *fenetre, const long intensite_min, const long intensite_max, unsigned char couleur_goutte1, unsigned char couleur_goutte2, unsigned char couleur_goutte3, long longueur_min_goutte, long longueur_max_goutte, long largeur_goutte)
{
    //Coordonnées aléatoires des goutes de pluie en X
    int i, j;
    srand(time(NULL)); //Initialisation du générateur
 
    unsigned long nbr_goutte = 0; //Nombre de goutes à l'écran
    nbr_goutte =  nbr_aleatoire(intensite_min, intensite_max); /*Génération d'un nombre aléatoire entre 1 et intensite
                                    et qui va représenter le nombre de goutes de pluie à l'écran*/
 
    unsigned long Coord_Goutte_X[nbr_goutte];//Tableau des coordonnées de toutes les goutes pour l'axe des abcisses
    unsigned long Coord_Goutte_Y[nbr_goutte];//Tableau des coordonnées de toutes les goutes pour l'axe des ordonnés
    for (i=1; i<nbr_goutte; i++)
    {
        Coord_Goutte_X[i] = nbr_aleatoire(1, 800);
        Coord_Goutte_Y[i] = nbr_aleatoire(1, 600);
    }
 
    //--------------------------------------------------------------------------
 
 
    //--------------------------------------------------------------------------
    //Création des tableaux + allocation de la mémoire
    SDL_Surface ** goutte = NULL;//Pointeur de surface qui va servir de tableau de surfaces
 
    goutte = malloc(nbr_goutte * sizeof(* goutte));//Allocation de la mémoire pour le tableau du nombre de gouttes aléatoire
    if (goutte == NULL)
        exit(0);
 
    //Boucle qui permet de coller trois fois le nombre de gouttes en vue de créer trois couches pour donner un effet de profondeur
    for(i = 1; i<nbr_goutte; i++)
    {
        SDL_Rect coord_goutte; //Coordonnées de la goutte qui va être dessinée
        coord_goutte.x = Coord_Goutte_X[i];//assignement d'une valeur aléatoire aux coordoonnées en X de la goutte qui va être dessinée
        coord_goutte.y = Coord_Goutte_Y[i];//Coordonnées de départ en Y de la goutte qui va être dessinée
        goutte[i] = SDL_CreateRGBSurface(SDL_HWSURFACE, largeur_goutte, nbr_aleatoire(longueur_min_goutte, longueur_max_goutte), 32, 0, 0, 0, 0);
        SDL_FillRect (goutte[i], NULL, SDL_MapRGB(fenetre->format, couleur_goutte1, couleur_goutte2, couleur_goutte3));
        SDL_BlitSurface (goutte[i], NULL, fenetre, &coord_goutte);
    }
 
    int temps_actuel = 0, temps_precedent = 0;
    temps_actuel = SDL_GetTicks();
    if (temps_precedent - temps_actuel == 30)
    {
        for (i=0; i<nbr_goutte; i++)
            Coord_Goutte_Y[i] =+ 1;
        temps_precedent = temps_actuel;
    }
    //Libération de la mémoire pour le tableau de surface
    for (i=0; i<nbr_goutte; i++)
        SDL_FreeSurface(goutte[i]);
    //--------------------------------------------------------------------------
 
 
    //--------------------------------------------------------------------------
    //Vérification de la variable en écrivant sa valeur sur l'écran
    TTF_Font *police = NULL;
    police = TTF_OpenFont("arial.ttf", 20);
    SDL_Color blanc = {255, 255, 255};
    SDL_Surface *texte = NULL;
    TTF_SetFontStyle(police, TTF_STYLE_ITALIC);
    char nombre[50] = ""; /* Tableau de char suffisamment grand pour contenir les chiffres du nombre aléatoire*/
    sprintf (nombre, "Nombre de gouttes à l'écran : %ld", nbr_goutte);
    texte = TTF_RenderText_Blended (police, nombre, blanc);
    SDL_Rect coord;
    coord.x = fenetre->w/2 - texte->w/2;
    coord.y = fenetre->h/2 - texte->h/2;
    SDL_BlitSurface (texte, NULL, fenetre, &coord);
    TTF_CloseFont(police);
 
}
 
///FIN PLUIE
///=============================================================================

Et mon fichier main :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
///=============================================================================
/*
main.c
 
-appel des librairies
-appel de génération_goutes.c
*/
#include "main.h"
///=============================================================================
 
 
 
///=============================================================================
/*
Libération du programme
*/
void Free()
{
    FSOUND_Close();
    SDL_Quit();
    TTF_Quit();
}
///=============================================================================
 
 
 
 
 
///=============================================================================
int main (int argc, char *argv[])
 
{
    //--------------------------------------------------------------------------
    //Initialisation des librairies
 
    SDL_Init (SDL_INIT_AUDIO | SDL_INIT_VIDEO);
    FSOUND_Init (44100, 64, 0);
 
    SDL_Surface *fenetre = NULL;
    fenetre = SDL_SetVideoMode (LARGEUR_FENETRE, HAUTEUR_FENETRE, RESOLUTION, SDL_HWSURFACE | SDL_DOUBLEBUF );
 
    if(TTF_Init() == -1)
    {
        fprintf(stderr, "Erreur d'initialisation de TTF_Init : %s\n", TTF_GetError());
        exit(EXIT_FAILURE);
    }
 
    if (SDL_Init(SDL_INIT_VIDEO) == -1)
    {
        fprintf(stderr, "Impossible de charger le mode vidéo de la SDL : %s\n", SDL_GetError());
        return EXIT_FAILURE;
    }
    if (SDL_Init(SDL_INIT_AUDIO) == -1)
    {
        fprintf(stderr, "Impossible de charger le mode audio de la SDL : %s\n", SDL_GetError());
        return EXIT_FAILURE;
    }
    if (fenetre == NULL)
    {
        perror("Erreur lors de la création de la fenêtre.\n");
        return EXIT_FAILURE;
    }
 
 
    if (FSOUND_GetVersion() < FMOD_VERSION)
    {
        fprintf (stderr, "Mauvaise version de la bibliothèque. Vous devriez utiliser la version %.02f\n", FMOD_VERSION);
        exit(1);
    }
    if (!FSOUND_Init (44100, 64, 0))
    {
        fprintf(stderr, "Erreur d'initialisation de FMOD : %s\n", FMOD_ErrorString(FSOUND_GetError()));
        exit(1);
    }
    atexit(Free);
    //--------------------------------------------------------------------------
 
 
    //--------------------------------------------------------------------------
    //Options de la fenêtre
 
    SDL_FillRect (fenetre, NULL, SDL_MapRGB(fenetre->format, COULEUR1, COULEUR2, COULEUR3));
    SDL_Flip(fenetre);
    SDL_WM_SetCaption (TITRE_FENETRE, NULL);
    //--------------------------------------------------------------------------
 
    pluie (fenetre, 20, 40, 180, 180, 255, 20, 40, 1);//Appel de la fonction pluie
 
    //--------------------------------------------------------------------------
    //Boucle générale
 
    unsigned char Continuer = 1;
    SDL_Event event;
 
    //Répétition des touches activées
    SDL_EnableKeyRepeat(120,120);
 
    while (Continuer)
    {//Début de la boucle principale
 
    //--------------------------------------------------------------------------
	//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;
	}
	//--------------------------------------------------------------------------
 
	SDL_Flip(fenetre);
    }//Fin de la boucle principale
    //--------------------------------------------------------------------------
 
 
    return EXIT_SUCCESS;
}//Fin de la fonction principale
///=============================================================================

Cette fois-ci avec des exemple :


pluie fais actuellement les choses suivantes :
->génération aléatoire des gouttes entre nbr_min et nbr_max en appellant une
autre fonction qui génère des nombres aléatoires
->génération des coordonnées aléatoires :
->création d'un tableau de surface pour contenir les gouttes
->affichage des gouttes à l'écran

Je suis donc maintenant en train d'essayer de faire en sorte que les gouttes défilent à l'écran (sans me préoccuper du fait qu'elles doivent être réaffichées en haut de l'écran lorsqu'elles sont sorties en bas de l'écran)

mais si je veux les faires défiler et en même temps gérer les événement de la fonction main, c'est impossible !
Alors comment les développeurs font-ils ? Il font bien plusieurs fichiers et ils auraient aussi géré pluie dans un autre fichier que main je suppose ?...

J'éspère avoir été assez clair sur ma question ou plutot mon problème...
Alors si quelqu'un pourrait m'aider ça serait vraiment sympa !

P.S : Ne vous préoccupez pas tu texte dans la fonction pluie ; il était simplement là pour voir quelles valeurs contenaient certaines variables. Je l'enlèverais bien sûr quand je finirais ce petit programme (si j'arrive )

[Emmanuel Delahaye]

<...>d'ou la nécessité qu'il soit entièrement indépendant du fichier main pour qu'il s'execute en même temps que le jeu à proprement dit.

J'ai déjà réussi à générer les coordonnées des gouttes et déjà en tête comment les faires défiler ; seulement voilà :
J'apelle la fonction pluie à partir du fichier main.c
Je souhaite donc n'apeller qu'une seule fois la fonction pluie et qu'elle gère le reste toute seule, mais je souhaite EN MEME TEMPS, par exemple, déplacer un personnage par exemple.

Mais si je n'apelle la fonction qu'une seule fois, c'est impossible qu'elle fasses tout pendant que le joueur déplace le personnage (à moins que je n'ai pas vraiment compris comment sont lu mes fichiers) ; et même si je voulais appeller la fonction dans une boucle dans main cela ne changerais rien car une fois que la fonction est finie et qu'elle est réapellée dans la boucle les variables seront remises à 0 puisqu'elles le sont dans la fonction pluie (et je ne veux pas le faire ailleurs)
<...>

Tu dois te renseigner sur la programmation multi-tâche...

Petit aperçu : http://emmanuel-delahaye.developpez.com/pthreads.htm

[Shugo78]

Tu dois lancer un processus indépendant
Regardes le lien d'Emmanuel pour commencer.

[Jordinateur]

Olalal c'est compliqué la programmation

On vient de finir d'apprendre quelque chose, et on se rend compte que en fait on ne sait vraiment rien

Bon j'ai lu et j'ai même essayé de comprendre les exemples qui sont un peu compliqué pour moi je trouves...

bon déjà je ne comprend pas les lignes du genre

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

p_data->psh->data = x;

Je n'ai rien appris de tel avec des flèches mais apparemment à ce que j'ai compris c'est un pointeur sur une fonction c'est bien sa ?

Bon alors globalement, on doit utiliser un truc qui permet de lancer deux fonctions en même temps. Et si on veut qu'à un certain moment le programme ne gère pas ces trucs on doit utiliser un machin qui s'apelle sémaphore c'est bien ça ?

Et si on veut complètement annuler l'inclusion des threads à un moment ou a un autre pour après les remettres quand on en a besoin ? C'est possible ?

[Emmanuel Delahaye]

Olalal c'est compliqué la programmation

On vient de finir d'apprendre quelque chose, et on se rend compte que en fait on ne sait vraiment rien

Bon j'ai lu et j'ai même essayé de comprendre les exemples qui sont un peu compliqué pour moi je trouves...

bon déjà je ne comprend pas les lignes du genre

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

p_data->psh->data = x;

Je n'ai rien appris de tel avec des flèches mais apparemment à ce que j'ai compris c'est un pointeur sur une fonction c'est bien sa ?
<...>

Non.

La programmation par threads est assez avancée et nécessite une bonne maitrise du langage C. Si ce n'est pas le cas, revoit tes ambitions à la baisse, et approfondi plutôt ta connaissance du langage C.

-> est basique. C'est l'opérateur qui permet d'atteindre un élément de pointeur sur structure. p->x est équivalent à (*p).x

[millie]

Tu dois lancer un processus indépendant
Regardes le lien d'Emmanuel pour commencer.

Attention, processus et threads sont différents.

[Thierry Chappuis]

Olalal c'est compliqué la programmation

On vient de finir d'apprendre quelque chose, et on se rend compte que en fait on ne sait vraiment rien

Bon j'ai lu et j'ai même essayé de comprendre les exemples qui sont un peu compliqué pour moi je trouves...

bon déjà je ne comprend pas les lignes du genre

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

p_data->psh->data = x;

Je n'ai rien appris de tel avec des flèches mais apparemment à ce que j'ai compris c'est un pointeur sur une fonction c'est bien sa ?

Bon alors globalement, on doit utiliser un truc qui permet de lancer deux fonctions en même temps. Et si on veut qu'à un certain moment le programme ne gère pas ces trucs on doit utiliser un machin qui s'apelle sémaphore c'est bien ça ?

Et si on veut complètement annuler l'inclusion des threads à un moment ou a un autre pour après les remettres quand on en a besoin ? C'est possible ?

Dans l'exemple d'Emmanuel, p_data est un pointeur sur une structure de type struct data. Cette structure contient un champ nommé psh. Ansi, pour accéder au champ psh, on fait

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
(*p_data).psh

Comme avec n'importe quelle structure. Comme cette construction est relativement fréquente, les créateurs du langage C ont introduit un opérateur qui prent en charge le déréférencement ET l'accès au champ psh. Il s'agit de l'opérateur '->'. On a donc:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

p_data->psh

Maintenant, le champ psh est lui-même un pointeur sur une structure de type struct shared contenant un champ appelé data. Pour accéder à ce champ data, on fait donc:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

p_data->psh->data

Ce qui est équivalent à:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

(*(*p_data).psh).data

L'opérateur "flèche" nous facilite bien la vie dans ce cas là, et comme tu peux le voir, cela n'a aucun rapport avec des pointeurs de fonctions.

En espérant avoir éclairé ta lanterne...

Meilleures salutations

EDIT: grillé par Emmanuel

Thierry

[Jordinateur]

La programmation par threads est assez avancée et nécessite une bonne maitrise du langage C. Si ce n'est pas le cas, revoit tes ambitions à la baisse, et approfondi plutôt ta connaissance du langage C.

Je ne te permet pas de me juger sur le simple fait que j'ai dit que je voulais faire un moteur de RPG 2D, surtout que j'ai dit que je voulais le faire plus-tard.

Je n'ai pas vraiment appris le C, j'ai plutôt appris quelque bases, mais je compte bien le faire, j'ai commandé un livre récemment et je l'attend toujours mais je vais quand même essayer de gérer les threads en attendant

-> est basique. C'est l'opérateur qui permet d'atteindre un élément de pointeur sur structure. p->x est équivalent à (*p).x

Je voulais dire un pointeur sur une structure !


Merci d'avoir éclairé ma lanterne Thierry !

Comme ça je comprends un peu mieux