Discussion :

[guitz]

Bonjour,

J'ai tout essayé pendant un long moment mais je ne suis parvenu à comprendre pourquoi ça ne marche pas.

dans Ball.h :

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
#pragma once
class Ball {
 
public:
 
	Ball( int posX, int PosY, int speedX, int speedY);
	~Ball( void );
 
	int m_x;
	int m_y;
	int m_speedX;
	int m_speedY;
 
	static Ball *balls[2];
 
	void updateBall(int posX, int PosY);
 
};

Dans Ball.cpp :

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
#include "Ball.h"
 
Ball * Ball::balls[2] = {0};
 
// build / destruct -------------------------------------------------------------------------
 
Ball::Ball( int posX, int posY, int speedX, int speedY)
{
	m_x = posX;
	m_y = posY;
	m_speedX = speedX;
	m_speedY = speedY; 
}
 
 
Ball::~Ball(void)
{
	//OutputDebugString("destruction ball\n");
}
 
void Ball::updateBall(int posX, int posY){
	m_x = posX;
	m_y = posY;
}

Et enfin dans le main.cpp :

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 <math.h>
#include "Ball.h"
 
...
...
 
Ball::balls[0] = new Ball((int)(-SCREEN_WIDTH/2+50), (int)(-SCREEN_HEIGHT/2+50), 10, 10);
Ball::balls[1] = new Ball(0, 0, 10, 10);
 
...
...
 
void HeartGame::routine () {
 
	{
 
		for(int i=0; i<=1; i++){ //On boucle sur toutes les billes
 
			Ball *b = Ball::balls[i];
 
			//b->updateBall(b->m_x + x, b->m_y + x);
 
			b->updateBall(b->m_x + b->m_speedX, b->m_y + b->m_speedY);
 
			HeartGraphics::drawSmallSprite( b->m_x , b->m_y, 0, 0 );
 
		} 
 
 
	}
 
}
 
...
...

Je précise que dans main.cpp si j'incrémente une variable x dans la routine :

Code :

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

HeartGraphics::drawSmallSprite( x , x, 0, 0 );

Les 2 balles se déplacent bien en diagonales, alors que dans le code posté plus haut les 2 balles restent fixes.
A votre avis pourquoi m_x et m_y ne sont pas mis à jour à chaque frame ?

Merci

[Iradrille]

Hello,

Code :

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

static Ball *balls[2];

C'est moche, pour plusieurs raisons :
- pourquoi est-ce que c'est statique ?
- pourquoi est-ce que c'est dans la classe Ball ?
- préfères les std::array aux tableaux C style.
- maintenir un tableau (vector ? ) de Ball est valable (non statique et dans une autre classe), mais quelle est la motivation pour avoir un tableau de pointeur ?

Pour l'erreur par contre je ne vois pas

Code :

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

1
2
3
4
void HeartGame::routine () {
	{
		for(int i=0; i<=1; i++){ //On boucle sur toutes les billes
		// ...

Ces doubles accolades + double indentation laisse penser qu'un morceau de code à été supprimé. Le problème peut venir de ce morceau de code manquant.

Code :

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

b->updateBall(b->m_x + b->m_speedX, b->m_y + b->m_speedY);

pourquoi ne pas simplement faire

Code :

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

1
2
b->m_x += b->m_speedX;
b->m_y += b->m_speedY;

vu que les attributs sont publiques.
(Il faut prendre en compte le temps écoulé aussi, sinon la vitesse de déplacement dépendra du framerate).

[guitz]

Bonsoir Iradrille,

Merci pour ta réponse.

C'est moche, pour plusieurs raisons :
- pourquoi est-ce que c'est statique ?
- pourquoi est-ce que c'est dans la classe Ball ?
- préfères les std::array aux tableaux C style.
- maintenir un tableau (vector ? ) de Ball est valable (non statique et dans une autre classe), mais quelle est la motivation pour avoir un tableau de pointeur ?

L'idée du statique c'est de créer une sorte de tableau global avec un "Ball::" devant pour clarifier le code (on sait que ça concerne les balls)

C'est dans la classe Ball car je croyais qu'il fallait creéer les variables statiques dans la classe en question

Merci pour le conseil des std::array, je vais l'appliquer

J'ai pas utilisé un vector car à l'avenir le nombre de billes sera constant (pas d'allocation dynamique ni de désalocation à gerer, les balls non utilisées seront placées en dehors de la scène.
J'ai utilisé un tableau de pointeurs car chaque objet est une adresse, donc un pointeur de type Ball *


Je viens d'essayer ce que tu mas conseillé :

Code :

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

1
2
3
4
5
6
...
                        b->m_x += b->m_speedX;
			b->m_y += b->m_speedY;
 
			HeartGraphics::drawSmallSprite( b->m_x , b->m_y, 0, 0 );
                        ...

ça ne marche pas, c'est ce que j'avais essayé en premier, le "+=" se comporte comme un "=" . C'est vraiment étrange

Merci

[Iradrille]

L'idée du statique c'est de créer une sorte de tableau global avec un "Ball::" devant pour clarifier le code (on sait que ça concerne les balls)

Si ce tableau à un gros rôle dans l'appli alors fais en une classe, sinon le tableau se retrouvera dans une autre classe (attribut d'une classe "Scene" par exemple).

J'ai utilisé un tableau de pointeurs car chaque objet est une adresse, donc un pointeur de type Ball *

Il n'y à ici pas d'intérêt : Ball n'est pas une classe héritée, il n'y à pas de polymorphisme.
un std::array<Ball, 2> balls; est plus adapté ici.

par exemple

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
class Ball {
public:
     int x, y, speedX, speedY;
     void update(float dt) {
          x += speedX * dt;
          y += speedY * dt;
      }
      Ball() { }
      Ball(int x, int y, int sx, int sy) : x(x), y(y), speedX(sx), speedY(sy) { }
      Ball(const Ball& b) : x(b.x), y(b.y), speedX(b.speedX), speedY(b.speedY) { }
      Ball& operator=(const Ball& b) {
          x = b.x;
          y = b.y;
          speedX = b.speedX;
          speedY = b.speedY;
          return *this;
      }
};
 
class BallArray {
public:
   typedef std::array<Ball, 2> array_type;
   typedef array_type::const_iterator const_iterator;
 
   void updateBall(unsigned int n, float dt) {
       if(n < m_array.size()) {
           m_array[n].update(dt);
       }
    }
    void updateAllBall(float dt) {
        for(auto& b: m_array) {
             b.update(dt);
         }
     }
 
     const_iterator begin() const { return m_array.begin(); }
     const_iterator end() const { return m_array.end(); }
 
private:
     array_type m_array;
};
 
class HeartGame {
public:
     void HeartGame::routine () {
           m_balls.updateAllBall(/* dt */);
           std::foreach(m_balls.begin, m_balls.end(), [](const Ball& b) {
                HeartGraphics::drawSmallSprite(b.x, b.y, 0, 0 );
           }
     }
 
private:
     BallArray m_balls;
};

[Bousk]

Bonsoir,

je vois à peu près rien qui empêcherait les balles de bouger dans ce code.
Il nous manquerait pas du code par hasard ? Parce qu'en l'état, je suis quasiment certain qu'en compilant ça, ça bougerait.

[skeud]

Les 2 balles se déplacent bien en diagonales, alors que dans le code posté plus haut les 2 balles restent fixes.
A votre avis pourquoi m_x et m_y ne sont pas mis à jour à chaque frame ?

Il y a que moi que ça choc? Il dit que les deux balles se déplacent bien en diagonale, c'est le but non?
Et c'est conforme avec le code.

Je comprends pas quelle erreur il y a en fait .

[Bousk]

Oui, quand il utilise une variable x qu'il incrémente dans cette fonction, pas quand il utilise m_X + m_speedX

[guitz]

Il y a que moi que ça choc? Il dit que les deux balles se déplacent bien en diagonale, c'est le but non?
Et c'est conforme avec le code.

Je comprends pas quelle erreur il y a en fait .

Bonjour skeud, j'ai passé un temps fou à essayer de comprendre pourquoi ça marche pas, je suppose maintenant que cest le fait d'avoir créer un tableau statique dans ma classe ball et dy avoir stocké des objets de type ball à lintérieur qui fait bugger. Je ne saurai expliquer pourquoi mais c'est la seule explication possible, voilà pourquoi je vais opter pour un code plus propre conseillé par Iradrille

[guitz]

Si ce tableau à un gros rôle dans l'appli alors fais en une classe, sinon le tableau se retrouvera dans une autre classe (attribut d'une classe "Scene" par exemple).

Il n'y à ici pas d'intérêt : Ball n'est pas une classe héritée, il n'y à pas de polymorphisme.
un std::array<Ball, 2> balls; est plus adapté ici.

par exemple

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
class Ball {
public:
     int x, y, speedX, speedY;
     void update(float dt) {
          x += speedX * dt;
          y += speedY * dt;
      }
      Ball() { }
      Ball(int x, int y, int sx, int sy) : x(x), y(y), speedX(sx), speedY(sy) { }
      Ball(const Ball& b) : x(b.x), y(b.y), speedX(b.speedX), speedY(b.speedY) { }
      Ball& operator=(const Ball& b) {
          x = b.x;
          y = b.y;
          speedX = b.speedX;
          speedY = b.speedY;
          return *this;
      }
};
 
class BallArray {
public:
   typedef std::array<Ball, 2> array_type;
   typedef array_type::const_iterator const_iterator;
 
   void updateBall(unsigned int n, float dt) {
       if(n < m_array.size()) {
           m_array[n].update(dt);
       }
    }
    void updateAllBall(float dt) {
        for(auto& b: m_array) {
             b.update(dt);
         }
     }
 
     const_iterator begin() const { return m_array.begin(); }
     const_iterator end() const { return m_array.end(); }
 
private:
     array_type m_array;
};
 
class HeartGame {
public:
     void HeartGame::routine () {
           m_balls.updateAllBall(/* dt */);
           std::foreach(m_balls.begin, m_balls.end(), [](const Ball& b) {
                HeartGraphics::drawSmallSprite(b.x, b.y, 0, 0 );
           }
     }
 
private:
     BallArray m_balls;
};

Bonsoir Iradrille,

Un grand merci pour ton code, je l'ai copié collé dans mon projet et essaie de le comprendre :

Pour la classe Ball :

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
class Ball {
public:
     int m_x, m_y, m_speedX, m_speedY;
     void updatePos(void) {
          m_x += m_speedX;
          m_y += m_speedY;
      }
      Ball() { }
      Ball(int x, int y, int sx, int sy) : m_x(x), m_y(y), m_speedX(sx), m_speedY(sy) { }
      Ball(const Ball& b) : x(b.x), y(b.y), speedX(b.speedX), speedY(b.speedY) { }
      Ball& operator=(const Ball& b) {
          x = b.x;
          y = b.y;
          speedX = b.speedX;
          speedY = b.speedY;
          return *this;
      }
};

Code :

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

 Ball() { }

Pourquoi ceci juste avant le constructeur ?

Code :

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

Ball(int x, int y, int sx, int sy) : m_x(x), m_y(y), m_speedX(sx), m_speedY(sy) { }

Ok c'est le constructeur mais je croyais qu'il fallait mettre le prototype du constructeur dans Ball.h et le corps dans Ball.cpp
Or là tu mets tout en un, pourquoi ?

Code :

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

1
2
3
4
5
6
7
8
Ball(const Ball& b) : x(b.x), y(b.y), speedX(b.speedX), speedY(b.speedY) { }
      Ball& operator=(const Ball& b) {
          x = b.x;
          y = b.y;
          speedX = b.speedX;
          speedY = b.speedY;
          return *this;
      }

Désolé mais je ne comprends pas ce code

[Iradrille]

Code :

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

 Ball() { }

Pourquoi ceci juste avant le constructeur ?

C'est un constructeur par défaut : un constructeur qui ne prend aucun paramètre.

Ok c'est le constructeur mais je croyais qu'il fallait mettre le prototype du constructeur dans Ball.h et le corps dans Ball.cpp
Or là tu mets tout en un, pourquoi ?

C'est effectivement préférable (bien que discutable dans le cas de fonctions aussi courtes).
Les deux sont possibles, mais c'est plus compréhensible comme ça (sur le forum, je ne séparerai jamais déclaration et définition).

Code :

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

1
2
3
4
5
6
7
8
Ball(const Ball& b) : x(b.x), y(b.y), speedX(b.speedX), speedY(b.speedY) { }
      Ball& operator=(const Ball& b) {
          x = b.x;
          y = b.y;
          speedX = b.speedX;
          speedY = b.speedY;
          return *this;
      }

Désolé mais je ne comprends pas ce code

Constructeur par copie et opérateur =, pour permettre ce genre de chose

Code :

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

1
2
3
4
Ball b; // appel du constructeur par défaut;
Ball b2(1, 1, 1, 1); // appel du constructeur prennant 4 ints
Ball b3(b2); // appel du constructeur par copie
b = b3; // appel de l'opérateur =

[guitz]

Merci à toi, je vais regarder tout ça

[oodini]

Code :

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

static Ball *balls[2];

C'est moche, pour plusieurs raisons :
- pourquoi est-ce que c'est statique ?

Comme disait Chirac :
"Ça m'en fait bouger l'une sans faire bouger l'autre."

[Iradrille]

Pas sur de comprendre ? (bien que j'aime l'expression )

Ça n'influence pas les objets de la classe Ball : le principe d'un attribut statique.
Mais ça n'a rien à faire dans la classe Ball. Et si c'est autre part ça ne sera très probablement pas statique.

[oodini]

Pas sur de comprendre ? (bien que j'aime l'expression )

balls, statique... ça m'a fait penser à l'expression... c'est juste le soleil qui m'avait mis d'humeur badine.