Déplacement de balle

Version imprimable

Bonjour,
Je me remet un peu au C++, et je suis en train de programmer un exécutable qui fait déplacer des balles dans la console windows.
J'ai réussi à créer une classe balle, avec une méthode: déplace balle.
Voici mon code:
Définition de la classe

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
#include <cstdlib>
#include <iostream>
#include <conio2.h>
#include <windows.h>
#include <time.h>
class Balle
{
  private:
          int balleX; //position courante axe X de la balle
          int balleY; //position courante axe Y de la balle
          char balleB; //Charactère représentant la balle
          int xB,yB; // itérateur pour le déplacement de ma balle
          int colorBalle; // donne une couleur à ma balle
          int speedBalle; // donne une vitesse de déplacement à ma balle
 
   public:
          Balle(int xBalle,int yBalle, char bBalle, int sPeedBalle); //initialisation de ma balle
          void moveBalle(void); //méthode pour déplacer la balle
 
};

Définition du constructeur et des méthodes:

Code:

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
//initialisation de  l'objet balle
Balle::Balle(int startX,int startY,char startNameBalle,int timeB)
{
          balleX = startX;
          balleY = startY;
          balleB = startNameBalle;
          xB = startX;
          yB = startY;
          textcolor(colorBalle);
          gotoxy(balleX,balleY);
          speedBalle = timeB;
          cout << balleB;
}
//méthode pour le déplacement de ma balle
void Balle::moveBalle(void)
{
        Sleep(speedBalle);
        //incrémentation des compteurs
        xB++;
        yB++;
         // j'efface ma balle
        gotoxy(balleX,balleY);
        cout << " ";
       //calcule des collisions de ma balle (fenêtre cmd en 80*25) 
        if(balleX <= 1 || xB <= 80)
        {
                   balleX++;
        }
        if(balleX >= 80 || xB >= 80)
        {
                 balleX--;
                 if(xB >= 160)
                         xB = 1;
 
        }
        if(balleY <=1 || yB <=25)
                  balleY++;
        if(balleY >=25 || yB >=25)
        {
                  balleY--;
                  if(yB >=50)
                        yB=1;
        }
        //colorisation aléatoire de ma balle à chaque déplacement
        textcolor(rand() % 10);
       //Affichage de la balle après déplacement
        gotoxy(balleX,balleY);
        cout << balleB;
}

mon main:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
int main(int argc, char *argv[])
{
    srand(time(NULL));
    //Déclaration d'un tableau de 2 balles
    Balle *tabB[2];
    //initialisation des Balles
    tabB[0] = new Balle(rand() % 80,rand() % 25,'A',10);
    tabB[1] = new Balle(rand() % 80,rand() % 25,'A',20);
    getchar();
    //déplacement des 2 balles
    while(int i = 1)
    {
     for(int i = 0; i<2; i++)
     {
             tabB[i]->moveBalle();
     }
    }
    system("PAUSE");
    return EXIT_SUCCESS;
}

En faite, j'aimerais que mes 2 balles aient des vitesses de déplacements différentes.
J'ai essayé d'utiliser la fonction Sleep(time), mais cela ne fonctionne pas tellement, puisque même si je définis 2 temps d'attentes différents, c'est le temps d'attentes le plus long qui est pris en compte. Du coup, mes 2 balles se déplacent à la même vitesse.

Est-ce qu'il y aurait une solution pour que mes 2 balles se déplacent à des vitesses différentes?

Merci beaucoup pour vos réponses.

PS: Pour information, je développe sour DevCpp. J'ai utilisé la librairie conio2.h de borland. J'ai donc accès à la fonction gotoxy(x,y) etc....
Aussi, mon code est dans un seul fichier qui s'appelle main.cpp

23/08/2013, 18h29
imperio

Une solution toute simple serait de faire une sorte de gestionnaire de fps (frame per second) et de deplacer les balles en fonction de ce gestionnaire et de leur propre vitesse. Ainsi a chaque tour de boucle, il te suffira juste de changer leur position par-rapport a leur vitesse.
23/08/2013, 22h13
phileo75

Bonjour,

Merci beaucoup pour cette réponse rapide.
En revanche, je ne vois pas comment créer se gestionnaire de fps...
Avec la librairie time.h, ce serait possible?

Merci d'avance.
24/08/2013, 00h58
imperio

Avec la fonction usleep (unix) et Sleep (windows) c'est largement faisable. Un peu de maths et ca fonctionnera. :P

Cherche un peu sur google si t'as du mal ou reviens demander ici mais essaie de trouver par toi-meme avant.

Citation:

Envoyé par phileo75

Bonjour,

Merci beaucoup pour cette réponse rapide.
En revanche, je ne vois pas comment créer se gestionnaire de fps...
Avec la librairie time.h, ce serait possible?

Merci d'avance.

Hello,
tu prends le problème à l'envers : au lieu de définir la vitesse de la balle comme le temps d'attente (sleep) entre 2 mouvements, donnes leur une "vraie" vitesse : leur vitesse de déplacement par seconde.

Dans l'idée ça donne quelque du genre
Code:

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 struct vec2 { float x, y; vec2& operator+=(const vec2& v) { x += v.x; y += v.y; return *this; } }; struct Ball { vec2 position; vec2 speed; // se déplace horizontalement de x cases par seconde, de même en vertical void move(float delta) { // delta = le temps écoulé depuis le dernier mouvement (= le temps d'un tour de boucle) position += speed * (delta / 1000.0f); // convertir delta en secondes } }; float delta = 100; std::chrono::milliseconds d(delta); std::vector<Ball*> balls; // ... while(1) { std::this_thread::sleep_for(d); for(auto& ball: balls) { ball->erase(); } for(auto& ball: balls) { ball->move(delta); ball->draw(); } }
Ici le temps de calcul des nouvelles positions et de dessin est considéré nul et donc pas pris en compte, tu peux le prendre en compte en calculant le temps que met un tour de boucle.

edit : effacer toutes les balles avant de les redessiner évite les mauvaises surprises : si une balle arrive sur l'ancienne position d'une autre, en fonction de l'ordre dans lequel tu les dessines, une balle peut disparaître.

Merci beaucoup pour toutes vos réponses!
Je crois que j'ai enfin trouver:
Voici comment j'ai fait:

J'ai rajouté à ma classe balle ceci:
Une variable pour la vitesse de ma balle.
Une variable pour crée une sorte de chronomètre
Une méthode pour gérer la vitesse de mes balles.

Voici le code:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Balle
{
  private:
          int balleX;
          int balleY;
          char balleB;
          int xB,yB;
          int colorBalle;
          int speedBalle;  // vitesse de la balle
          int chronoTime;  // chronomètre
   public:
          Balle(int x,int y, char b, int t);
          void moveBalle();
          int randomBalle(int minB, int maxB);
          void vetifSpeedBall(clock_t timming); //méthode pour gérer la vitesse de mes balles   
};

A l'initialisation, je donne comme valeur au chronomètre la vitesse de ma balle

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
Balle::Balle(int startX,int startY,char startNameBalle,int sBalle)
{
          balleX = startX;
          balleY = startY;
          balleB = startNameBalle;
          xB = startX;
          yB = startY;
          textcolor(colorBalle);
          gotoxy(balleX,balleY);
          speedBalle = sBalle;     // initialisation de la vitesse des balles
          cout << balleB;
          chronoTime = speedBalle; // initialisation du chrono
}

Ensuite dans la méthode qui gère la vitesse de mes balles, j'utilise le nombre de clock() processeur courant. Puis si le nombre de clock() courant est égale au nombre de clock() courant plus mon chronomètre, alors je déplace ma balle. Je démcrémente bien évidement mon chrono dans le même temps.

Code:

1
2
3
4
5
6
7
8
9
10
11
int Balle::vetifSpeedBall(clock_t timming)
{
 
    if(timming+1 == chronoTime+timming) // si chrono arrivé a zero, move de la balle
                 moveBalle();
 
    chronoTime--;
    if(chronoTime == 0)
          chronoTime = speedBalle;      
     return 0;             
}

Et mon main:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
int main(int argc, char *argv[])
{
    srand(time(NULL));
    clock_t timestamp;    //initialisation du tps
    Balle *tabB[10];
    for(int i = 0; i < 10; i++)
    {
     int long randBalle = random(100,900); //vitesse aléatoire pour chaque balle
     tabB[i] = new Balle(rand() % 80,rand() % 25,'A',randBalle*1000); //multiplié par 1000 pour voir ce que ça donne à l'écran
 
    }
    getchar();
    while(int i = 1)
    {
     for(int i = 0; i<10; i++)
     {
             timestamp = clock();
             tabB[i]->vetifSpeedBall(timestamp);
     }
    }
    system("PAUSE");
    return EXIT_SUCCESS;
}

Et le tout fonctionne!

Merci à tous pour vos aide.
Je sais aussi que ce programme ne sert strictement à rien, mais c'est plus pour apprendre que je fais ça...

27/08/2013, 14h16
Médinoc

Attention, l'affichage de la balle n'a rien à faire dans son constructeur.

Ou du moins, même s'il est utilisé dans le constructeur, il devrait au moins être dans une fonction à part, appelée au besoin par celui-ci.
27/08/2013, 14h43
Astraya

Si c'est pour apprendre dans ce cas je reverrait ta fonction pour déplacer la balle.
Tu as une vitesse qui est X pixel / second.
Tu as clock qui te donne le nombre de clicks, tu dois diviser par CLOCKS_PER_SEC pour avoir le nombre de milliseconde.
Tu récupères la différence de cette valeur entre chaque frame. Ça te donne un delta avec ce delta, tu peux simplement trouver la position actuel connaissant la vitesse, le point de départ et le temps delta.

Tu le compares toujours en >= et pas en ==, tu auras peu de chance que ça fonctionne sinon et je me demande même si tu as un résultat vraiment correct avec ton code la.