Discussion :

[Princeless74]

Bonjour, voici mon projet

je dois créer un jet d'eau avec des gouttes d'eau, mais j'aimerais pouvoir apeller ma classe contenant le code réalisant la trajectori ed'une goutte de façon à ce que une seconde goutte se lance avant que la première ait fini d'être executée.

Apparament on m'a "soufflé" de la part d'un ami que la solution serais d'instancier la classe ce qui me permettrai d'avoir plusieurs gouttes en l'air en même temps

c'est la que je suis perdu et que j'ai besoin d'un coup de génie et d'aide de votre part ... Merci d'avance a tous !

voici les sources :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
#ifndef C_particules
#define C_particules
 
class particules
{
	public:
 
 
                particules();
                void jet();
                ~particules();
};
#endif

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
#include "particules.h"
#include "Unit1.h"
#include "math.h"
 
 
particules::particules()
{
 
}
 
void particules::jet()
{
 
  float Px=680,Py=300,accel=0,i=2,i2=0,Vx=2,Vy=-5,g=9.8;
 
        for(i2=0;i2<100;i2++)
        {
 
        //Effacer
        Form1->Canvas->Pen->Color = clBlack;
        Form1->Canvas->Pen->Width = 3;
        int Dx = 2;
        int Dy = 2;
        Form1->Canvas->RoundRect(Px, Py, Px + Dx, Py + Dy, Dx/2, Dy/2);
        i+=0.001;
        accel=(g/2)*(i);
        Vy+=accel-g;
        Py=Py+Vy;
        Px=Px+Vx;
 
        //Créer un nouveau point
        Form1->Canvas->Pen->Color = clSkyBlue;
        Form1->Canvas->RoundRect(Px, Py, Px + Dx, Py + Dy, Dx/2, Dy/2);
        Sleep(10);
  }
}
 
 
 
particules::~particules()
 
{
 
}

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
//---------------------------------------------------------------------------
#include "particules.h"
#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
#include "math.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
particules *eau;
 
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
 
}
 
//-----------------------------------------------------------
 
void __fastcall TForm1::FormActivate(TObject *Sender)
{
  WindowState = wsMaximized;
  Timer1->Interval = 500;
  randomize();
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Timer1Timer(TObject *Sender)
{
 
eau->jet();
 
}
//---------------------------------------------------------------------------

[zais_ethael]

Je n'ai pas bien compris le mode de fonctionnement de ton programme, mais j'ai l'impression qu'il est mauvais.
Plutot que de te dire ce qui cloche, je vais plutot te proposer un mode de fonctionnement assez classique pour gérer une animation dans un jeux 2D simple.

Dans les jeux on n'utilise pas d'algorithme pensant par itération, il n'est pas question de faire des ++ sur des variables puis de faire un sleep(). Les jeux fonctionnent sur base d'un état et d'une boucle infinie qui fait trois choses consécutives:
- gérer les évènements
- actualiser l'état en prenant en compte l'état précédent et la variable temps
- afficher la scène
Dans ton cas par exemple, l'état serait le moment où s'est effectué la dernière actualisation et un tableau contenant toutes les particules en activité, une particule étant définie par sa position, sa vitesse et sa trajectoire.
Actualiser l'état consisterait donc à calculer la nouvelle position de toutes les particules en prenant en compte vitesse, trajectoire et le temps écoulé entre la dernière actualisation et maintenant.
Ensuite l'affichage de la scène consiste simplement à effacer le buffer puis à peindre chaque particule à la position indiquée.

L'avantage de ce mode de fonctionnement est que la vitesse de l'ordinateur influe sur le framerate et pas du tout sur la vitesse du jeux. Certains vieux jeux n'utilisaient pas ce principe et tournent trop vite sur des ordinateurs trop rapides (qui se souvient de Theme Park?).

Pour ce programme précis il y a une subtilité: tu utilises un framework graphique. Il faut donc penser un peu différement.
En fait un framework graphique gère déja un boucle infinie et une gestion des évènements, tu ne peux donc le faire toi même. Tu dois utiliser un timer répetitif qui lancera un évènement à intervale régulier (50 millisecondes me semble pas mal, ça fait 20 images par secondes, mais de toutes façons si tu fais un bon algo tu peux faire varier ce paramètre à loisir), cet évènement ayant pour but d'actualiser l'état et de peindre la scène.

Voila, à toi de voir si tu veux t'inspirer mais surtout retiens bien ceci: pour faire des animations les algos dépendants du framerate et les sleep() c'est mal!

[Princeless74]

J'ai disons a moitié saisi ta réponse, qui me semble complexe vu le niveau d'études ou je suis ( BTS )

Le but final est de faire une fontaine d'eau avec des points qui se déplacent.

Je comprends bien pourquoi ne pas utiliser d'incrémentation de variables, mais je vois mal ce que je dois utiliser dans ce cas pour avoir un comportement réaliste de ma goutte d'eau ( plus le jet monte moins il monte vite, puis il sera attiré par la gravité, ce que je fais avec mes incrémentations en fait )

Après mon soucis c'est de lancer plusieurs particules en même temps...

[zais_ethael]

Mais ça n'a rien à voir avec tes calculs de trajectoire.
Ta question implique que tu sais déja calculer la trajectoire de tes particules, la je suis en train de t'expliquer comment concilier correctement ta math avec un programme informatique.
Qu'est-ce que tu ne comprends pas?

[moldavi]

Bonjour.

Suis pas certain de comprendre toutes tes questions, mais je me lance.

D'abord je ferai une classe particule (au singulier) :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
class particule
{
	public:
 
 
                particule();
                void draw();
                ~particule();
};

Ensuite je ferais une classe jet d'eau :

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
 
class geyser{
	public:
 
 
                geyser();
                void init_particules();
                void move_particules();
                void draw_particules();
                ~geyser();
 
            private:
 
               vector<particule> m_vMesParticules;
};

En fait, un jet d'eau est formé par des goutelettes d'eau.

une goutelette d'eau = une classe particule
un jet d'eau = plusieurs goutelettes d'eau (plusieurs classes particule).

Après le rôle de la classe geyser sera de controler les particules:

- init_particules : tu créés les particules dont tu as besoin, avec une trajectoire et une vitesse initiale.
- move_particules : tu déplaces tes particules en mettant à jour la vitesse par exemple (plus elles montent et plus elles ralentissent).
- draw_particules: y a plus qu'à afficher la nouvelle position des particules.

Pour quelque chose de beaucoup plus détaillé, cherches sur google "système de particule en C++".

[Princeless74]

merci pour vous réponses, je suis a terme arrivé a solutionner mon problème avec un tableau 2D contenant les trajectoires tout comme indiqué et cela marche parfaitement !

Merci !

[yan]

merci pour vous réponses, je suis a terme arrivé a solutionner mon problème avec un tableau 2D contenant les trajectoires tout comme indiqué et cela marche parfaitement !

Merci !

Bonjour,
un tableau 2D? comment cela