Développement de projets persos

**Bysbobo** · 17/07/2015, 19h59

Bonjour à tous,

J'ouvre ce topic parce que j'ai envie d'apprendre en développant des petits projets personnels. Essentiellement des jeux vidéos, on verra ensuite

Dans un premier temps et comme beaucoup, j'ai trouvé sur un célèbre site le jeu Pong.

Donc, premier projet: le jeu du Pong

Voici le code (il manque pas mal de finitions) mais n'hésitez pas à tout regarder. Donnez-moi vos impressions, commentaires et j'essayerai de m'adaptez

Pong.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
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
#include <SFML/Graphics.hpp>
#include "Balle.h"
#include "Barre.h"
#include "CollisionManager.h"
#include "iostream"
 
const std::string SPRITES_FILE_PATH = "Sprite.png";
const std::string MAP_FILE_PATH = "Map.png";
const sf::Vector2f WINDOW_SIZE(800, 600);
const sf::Vector2i WINDOW_POSITION(300, 200);
const sf::IntRect SUBRECT_BALLE(28, 0, 12, 12);
const sf::IntRect SUBRECT_BARREBLEUE(14, 0, 12, 45);
const sf::IntRect SUBRECT_BARREROUGE(0, 0, 12, 45);
const sf::Vector2f POS_BALLE(400, 300);
const sf::Vector2f POS_BARREROUGE(100, 300);
const sf::Vector2f POS_BARREBLEUE(700, 300);
const int VITESSE_BARRE = 4;
const double VITESSE_BALLE = 2;
 
int main()
{
    sf::RenderWindow window(sf::VideoMode((int)WINDOW_SIZE.x, (int)WINDOW_SIZE.y), "Jeu pong");
    //window.setPosition(WINDOW_POSITION);
    window.setFramerateLimit(60);
 
    sf::Image imageMap;
    sf::Texture textureMap;
    sf::Sprite spriteMap;
 
    if(!imageMap.loadFromFile(MAP_FILE_PATH))
    {
        std::cout << "Error during import" << std::endl;
        return EXIT_FAILURE;
    }
    else
    {
        if(!textureMap.loadFromImage(imageMap))
        {
            std::cout << "Error during loading" << std::endl;
            return EXIT_FAILURE;
        }
        else
        {
            spriteMap.setTexture(textureMap);
        }
    }
 
    Balle balle(SPRITES_FILE_PATH, SUBRECT_BALLE, POS_BALLE, VITESSE_BALLE);
    Barre barreRouge(SPRITES_FILE_PATH, SUBRECT_BARREROUGE, POS_BARREROUGE, VITESSE_BARRE);
    Barre barreBleue(SPRITES_FILE_PATH, SUBRECT_BARREBLEUE, POS_BARREBLEUE, VITESSE_BARRE);
 
    CollisionManager colMan(balle, barreRouge, barreBleue, WINDOW_SIZE);
 
    bool pause = false;
    bool init = false;
 
    while (window.isOpen())
    {
        sf::Event event;
 
        if (event.type == sf::Event::Closed)
            window.close();
        if (sf::Keyboard::isKeyPressed(sf::Keyboard::Escape))
            window.close();
 
        if (sf::Keyboard::isKeyPressed(sf::Keyboard::Space))
            pause = false;
 
        if (!pause)
        {
            barreRouge.moveBarre(WINDOW_SIZE.y, 1);
            barreBleue.moveBarre(WINDOW_SIZE.y, 2);
            balle.moveBalle(WINDOW_SIZE);
        }
        else
        {
            if (init)
            {
                balle.initBalle(POS_BALLE);
                init = false;
            }
        }
 
        colMan.manageCollision(pause, init);
 
        window.clear();
        window.draw(spriteMap);
        window.draw(barreBleue.getSprite());
        window.draw(barreRouge.getSprite());
        window.draw(balle.getSprite());
        window.display();
    }
 
    return EXIT_SUCCESS;
}

Balle.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
19
20
21
22
23
24
25
26
27
28
29
30
#ifndef BALLE_H_INCLUDED
#define BALLE_H_INCLUDED
 
#include <SFML/Graphics.hpp>
 
class Balle
{
public:
    Balle(const std::string &filePath, sf::IntRect subRect, sf::Vector2f position, int vitesse);
 
    void moveBalle(sf::Vector2f windowSize);
    void reverseMoveX();
    void reverseMoveY();
 
    void initBalle(sf::Vector2f positionBalle);
 
    sf::Sprite getSprite();
    sf::IntRect getPos() const;
 
private:
    sf::Image m_image;
    sf::Texture m_texture;
    sf::Sprite m_sprite;
 
    int m_vitesse;
    int m_dX;
    int m_dY;
};
 
#endif // BALLE_H_INCLUDED

Balle.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
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
#include "Balle.h"
#include "CollisionManager.h"
#include <iostream>
 
Balle::Balle(const std::string &filePath, sf::IntRect subRect, sf::Vector2f position, int vitesse)
: m_dX(vitesse), m_dY(vitesse)
{
    if(!m_image.loadFromFile("Sprite.png"))
    {
        std::cout << "Error during import" << std::endl;
    }
    else
    {
        m_image.createMaskFromColor(sf::Color::White);
 
        if(!m_texture.loadFromImage(m_image, subRect))
        {
            std::cout << "Error during loading" << std::endl;
        }
        else
        {
            m_texture.setSmooth(true);
            m_sprite.setTexture(m_texture);
            m_sprite.setPosition(position);
        }
    }
}
 
sf::Sprite Balle::getSprite()
{
    return m_sprite;
}
 
void Balle::moveBalle(sf::Vector2f windowSize)
{
    if(m_sprite.getPosition().x <= 0 || m_sprite.getPosition().x + 12 >= windowSize.x)
        reverseMoveX();
 
    if(m_sprite.getPosition().y <= 0 || m_sprite.getPosition().y + 12 >= windowSize.y)
        reverseMoveY();
 
    m_sprite.move(m_dX, m_dY);
}
 
void Balle::reverseMoveX()
{
    m_dX *= -1;
}
 
void Balle::reverseMoveY()
{
    m_dY *= -1;
}
 
void Balle::initBalle(sf::Vector2f positionBalle)
{
    m_sprite.setPosition(positionBalle);
}
 
sf::IntRect Balle::getPos() const
{
    sf::IntRect pos;
 
    pos.left = m_sprite.getPosition().x;
    pos.top = m_sprite.getPosition().y;
    pos.width = 12;
    pos.height = 12;
 
    return pos;
}

Barre.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
19
20
21
22
23
#ifndef BARRE_H_INCLUDED
#define BARRE_H_INCLUDED
 
#include <SFML/Graphics.hpp>
 
class Barre
{
public:
    Barre(const std::string &filePath, sf::IntRect subRect, sf::Vector2f position, int vitesse);
    sf::Sprite getSprite();
    void moveBarre(int windowSizeMax, int numJoueur);
    sf::IntRect getPos() const;
 
private:
    sf::Image m_image;
    sf::Texture m_texture;
    sf::Sprite m_sprite;
 
    int m_vitesse;
    int m_dY;
};
 
#endif // BARRE_H_INCLUDED

Barre.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
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
#include "Barre.h"
#include <iostream>
 
Barre::Barre(const std::string &filePath, sf::IntRect subRect, sf::Vector2f position, int vitesse)
: m_vitesse(vitesse)
{
    if(!m_image.loadFromFile("Sprite.png"))
    {
        std::cout << "Error during import" << std::endl;
    }
    else
    {
        m_image.createMaskFromColor(sf::Color::White);
 
        if(!m_texture.loadFromImage(m_image, subRect))
        {
            std::cout << "Error during loading" << std::endl;
        }
        else
        {
            m_texture.setSmooth(true);
            m_sprite.setTexture(m_texture);
            m_sprite.setPosition(position);
        }
    }
}
 
sf::Sprite Barre::getSprite()
{
    return m_sprite;
}
 
/*
** Numero de joueur: 1 => Barre rouge
** Numero de joueur: 2 => Barre bleue
*/
void Barre::moveBarre(int windowSizeMax, int numJoueur)
{
    switch(numJoueur)
    {
    case 1:
        if(sf::Keyboard::isKeyPressed(sf::Keyboard::Z) && m_sprite.getPosition().y > 0)
            m_sprite.move(0, (-1)*m_vitesse);
        if(sf::Keyboard::isKeyPressed(sf::Keyboard::S) && m_sprite.getPosition().y + 45 < windowSizeMax)
            m_sprite.move(0, m_vitesse);
        break;
 
    case 2:
        if(sf::Keyboard::isKeyPressed(sf::Keyboard::Up) && m_sprite.getPosition().y > 0)
            m_sprite.move(0, (-1)*m_vitesse);
        if(sf::Keyboard::isKeyPressed(sf::Keyboard::Down) && m_sprite.getPosition().y + 45 < windowSizeMax)
            m_sprite.move(0, m_vitesse);
        break;
 
    default:
        break;
    }
}
 
sf::IntRect Barre::getPos() const
{
    sf::IntRect pos;
 
    pos.left = m_sprite.getPosition().x;
    pos.top = m_sprite.getPosition().y;
    pos.width = 12;
    pos.height = 45;
 
    return pos;
}

CollisionManager.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
19
20
21
22
23
24
#ifndef COLLISIONMANAGER_H_INCLUDED
#define COLLISIONMANAGER_H_INCLUDED
 
#include <SFML/Graphics.hpp>
#include "Barre.h"
#include "Balle.h"
 
class CollisionManager
{
public:
    CollisionManager(Balle &balle, Barre &barre1, Barre &barre2, sf::Vector2f windowSize);
 
    void manageCollision(bool &pause, bool &init);
 
private:
    Balle &m_balle;
    Barre &m_barre1, &m_barre2;
 
    sf::Vector2f m_windowSize;
};
 
bool Collision(const sf::IntRect &a, const sf::IntRect &b);
 
#endif // COLLISIONMANAGER_H_INCLUDED

CollisionManager.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
36
37
38
39
40
41
42
43
44
45
46
#include "CollisionManager.h"
 
#include <iostream>
 
CollisionManager::CollisionManager(Balle &balle, Barre &barre1, Barre &barre2, sf::Vector2f windowSize):
m_balle(balle), m_barre1(barre1), m_barre2(barre2), m_windowSize(windowSize)
{
 
}
 
void CollisionManager::manageCollision(bool &pause, bool &init)
{
    sf::IntRect balleRect = m_balle.getPos();
 
    sf::IntRect barre1Rect, barre2Rect;
    barre1Rect = m_barre1.getPos();
    barre2Rect = m_barre2.getPos();
 
    if(Collision(balleRect, barre1Rect) || Collision(balleRect, barre2Rect))
    {
        m_balle.reverseMoveX();
 
    }
    else
    {
        if(balleRect.left <= 0 || balleRect.left + balleRect.width >= m_windowSize.x)
        {
            pause = true;
            init = true;
        }
    }
}
 
bool Collision(const sf::IntRect &a, const sf::IntRect &b)
{
    if(a.top + a.height <= b.top)
        return false;
    if(a.top >= b.top + b.height)
        return false;
    if(a.left + a.width <= b.left)
        return false;
    if(a.left >= b.left + b.width)
        return false;
 
    return true;
}

De plus, j'ai un bug minime: Quand je veux bouger la fenêtre pendant le jeu, la fenêtre se plante mais le jeu continue comme si de rien n'était! Je trouve pas...

**LittleWhite** · 18/07/2015, 14h43

Bonjour,

Vraiment, y a très peu à redire.
Il y a pour moi, un problème de conception/de nommage pour le CollisionManager. Surtout que le terme Manager est banni chez certain.

Sinon, dans le constructeur de Barre :

Code :

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

sf::IntRect subRect, sf::Vector2f position,

On peut passer cela par référence constante. On évitera ainsi une copie.

**Bysbobo** · 21/07/2015, 20h15

Bonsoir,

Merci pour ta réponse. Le projet n'est pas énorme mais au moins ça réconforte de voir que ça peut aller

Je suis en train de lire différents posts du lien que tu m'as donné. J'essayerais de donner un retour en fonction des difficultés que j'ai pour avancer.
Et j'ai modifié les paramètres en référence constante histoire d"être propre.

Quel est, selon toi, le problème de conception pour les collisions?

En revanche, j'ai toujours ce bug bizarre qui fait que je ne peux pas déplacer ma fenêtre de jeu pendant qu'elle tourne...
Aurais-tu une idée du pourquoi? J'ai le même bug sur un autre projet alors que cela ne me le faisait pas au début.

Merci beaucoup!

**LittleWhite** · 25/07/2015, 14h31

En revanche, j'ai toujours ce bug bizarre qui fait que je ne peux pas déplacer ma fenêtre de jeu pendant qu'elle tourne...
Aurais-tu une idée du pourquoi? J'ai le même bug sur un autre projet alors que cela ne me le faisait pas au début.

Je crois que c'est lié à Windows et on ne peux pas faire autrement. Sinon, mon projet fonctionne sous Linux, je peux jouer et déplacer la fenêtre (et vomir

).

Pour l'histoire des collisions, c'est surtout une question de design (organisation et architecture du programme).
Lorsque vous construisez le "CollisionManager" vous passez tous les éléments à vérifier en paramètre. Ok, cela fonctionne car vous n'avez que trois éléments pour le moment, mais comment allez vous faire avec un jeu comportant une centaine d'éléments ?
Mon idée, serait d'avoir une sorte de boite à outils permettant de vérifier les collisions. Pour ce faire, vous pouvez faire une classe et y mettre des fonctions statique. Ainsi, dès que vous avez besoin de vérifier une collision, vous appelez une des fonctions statique (pas besoin d'instance de la classe).
Enfin, c'est une idée comme une autre.

**Bysbobo** · 25/07/2015, 17h29

Oui j'ai suivi un tuto qui montrait la gestion des collisions avec une classe.
Bon, après tout, je ne voyais pas plus l'intérêt à moins de faire travailler les classes et quelques particularités liées au C++.

Je vais finir quelques finitions mais je vais surtout m'attaquer à un peu plus compliqué: une réplique de Mario.
J'ai trouvé de bonnes explications sur votre site pour m'y essayer. Je galère légèrement à afficher aux bons moments ma map et éviter des lags (il y a comme un manque de réactivité sur la lecture des events...).

Je continuerai sur le même post pour montrer ce que j'ai pu faire (un jeu comme Unblock sur AppStore, le BomberMan que j'ai mis en pause depuis un certain temps et tout et tout), j'espère que vous pourrez continuer à regarder mes créations. Merci!

Développement de projets persos

SFML

Discussions similaires

Partager

Partager