Discussion :

[romnair]

Présentation :

Moi sait romnair, 17ans, cela fait 3 mois que je me suis remis à la programmation, après une pause de 3ans(Yo Neckara...), la maturité que j'ai acquise pendant ses 3 années m'ont permit de revenir encore plus fort vers ma passion la programmation.

Alors voila, après mon retour j'ai utilisé mes acquis(pluôt maigre) en C++ afin de renouer avec la programmation et ainsi mener un jeu à sont terme; pour ce faire je me suis orienté vers SFML car elle possède une bonne doc et des tutos assez facile à comprendre, et car sa syntaxe est proche du C++, ainsi armé j'ai codé codé et codé et je suis arrivé a faire exactement 6 (petit)jeux sur lesquelles j'ai beaucoup appris, il m'est apparut de plus en plus clairement à quelle point la modularité des projets pouvé m'aidé à faire un travail plus portable et plus facile à manier.

C'est justement sur ce point que je veux travaillé car je n'arrive pas à bien m'orienté afin de faire les choses de la bonne manière, souvent les partit portable de mon code se résume à un gestionnaire "d'object sur l'écran", "une class pour les bouton", "un gestionnaire d'input précis", et je me demandé si il y avait des bonnes bases à avoir afin d'optimiser la portabilité et ainsi permettre une bonne séparation afin de gérée les erreurs plus facilement et m'aidé à crée des jeux avec plus de facilité.

[LittleWhite]

Bonjour,

Les bases sont plus ou moins toujours les mêmes, quelques soit le langage :

• avoir des classes et des fonctions qui ne font qu'une unique chose (principe de responsabilité unique) ;
• éviter les dépendances ;
• apprendre à faire du code pouvant évoluer, mais où le développeur ne peux pas non plus, mal utiliser le code.

Enfin, ce sont des exemples. Il y en a d'autres et le forum C++ en parle très souvent dans ses discussions.

[romnair]

J'ai fait des recherches complémentaires, j'ai survolé le principe de pattern, la modélisation des class pré-codé et je me demandé si ils étaient adapté dans mon optique de clarté et modularité de code et aussi si ils peuvent être transplanté dans une optique jeu vidéo.
Je me demandé aussi, si vous aviez des tutos(dans le cas ou ses 2 principes sont cohérent dans mon cas) adapté à un débutant ?

@LittleWhite :

- Que veut tu dire par dépendance ?(variable global ? besoin de class externe ?) et dans le cas de l'héritage la dépendance est toléré jusqu'a quelle point ?
- Je vais faire des recherches sur les 2 autres points sur la manière de les appliqués et leurs compréhension global et je ferai un petit compte rendu pour voir si ma compréhension n'est pas erronée(par contre n'attend pas ma réponse dans l'heure ou le jour qui suit, car je fait autre chose à côté, XD)
- Pour le forum je ferai un tour, sait aussi dans cet section que j'ai vu le principe de pattern vite fais.

PS : Désolé, si les "bonjour", "bonsoir", ne sont pas fait de ma part mais comme on se répond souvent en différé il m'est difficile de m'y retrouvé, xD.

[LittleWhite]

Les design pattern sont là, pour répondre à des besoins et des problématiques précises.
Les templates sont là, comme fonctionnalités d'un langage (notamment le C++) pour permettre au compilateur de travailler sur ce que sera le programme (bon, ça cela peut être dur à voir).
Pour votre programme, il faut une bonne logique, où toutes les classes sont "logique" et quelle n'ont qu'une seule responsabilité. Aussi, pour l'histoire des dépendances, si je me rappelle bien, il faut regarder du coté du principe ouvert/fermé (le blog d'Emmanuel Deloget est génial pour ça).

Pour le reste, montrez nous le code de vos petits jeu, disons, du mieux codé et on verra ce que l'on peux en dire.

[Bousk]

Salut,

ça va peut-être te paraître fou mais : programmer un jeu c'est foncièrement pas différent de n'importe quel autre programme.
Après chacun sa spécialité bien sûr.

Enfin ça c'est la théorie, parce que quand viens le moment de shipper, on peut être prêt à tout.

[romnair]

Merci pour vos réponses.

@LittleWhite : Je prendrai en contre le blog que tu à cité pendant mes recherches, pour ce qui est d'un code de jeu j'aimerais en refaire un pour ma passion personnel et essayer avant de commencer mes recherches de mettre en pratique mes acquis bien quelle soit pour l'instant plutôt maigre, mais je posterai mon petit jeu.

@Bousk : je comprend bien mais le bémol sait que, dans le domaine logiciel comme celui du jeu-vidéo mes compétences sont nul car malgré mes efforts je ne suis qu'un simple lycéen de 1ere par contre si tu à des liens qui montre de bonne règles de programmation applicable dans les 2 orientations je suis preneurs.

[LittleWhite]

Peut être cette vidéo vous aidera : http://jeux.developpez.com/videos/Cp...pement-rapide/

[romnair]

Alors voila après avoir fait des recherches sur comment bien se préparé pour crée un jeu, beaucoup de chose j'ai appris, et aujourdhui j'ai fais la connaissance avec la perte de motivation du à une très mauvaise gestion de la programmation, malgré tout je poste mon code qui forme les racines du jeu, n'oubliez pas je veux des retours sur ma manière d'agencé mon code et aussi que cette syntaxe est ma syntaxe avant d'avoir crée se sujet afin de montrer ma manière de codé(qui à bien changé grâce à vous merci mais je tenai à avoir un ressenti extérieur).

main.cpp :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
#include "moteur.hpp"
 
int main(void)
{
    Moteur game(LoadFromSetInt("Setting.txt", "ecran:"), LoadFromSetInt("Setting.txt", "ecran:"), LoadFromSetString("Setting.txt", "titre:"));
 
    game.Init();
 
    game.Loop();
 
    return 0;
}

moteur.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
#include "moteur.hpp"
 
Moteur::Moteur(int largeur, int hauteur, std::string title)
{
    window.create(sf::VideoMode(largeur, hauteur), title);
    window.setFramerateLimit(60);
    t_brick.loadFromImage(LoadImage(LoadFromSetString("Setting.txt", "texturebrick:")));
    t_perso.loadFromImage(LoadImage(LoadFromSetString("Setting.txt", "textureperso:")));
}
 
void Moteur::Init(void)
{
    test.Init(t_brick, t_perso);
}
 
void Moteur::Loop(void)
{
    while(window.isOpen())
    {
        if(ev.Ip_Close == true)
        {
            window.close();
        }
 
        ev.Update(window);
 
        if(ev.Ip_Esc)
        {
            test.Restart();
 
            ev.Ip_Esc = false;
        }
 
        test.Update(window, ev);
 
        Draw();
    }
}
 
void Moteur::Draw(void)
{
    window.clear(sf::Color::Black);
 
    test.Draw(window);
 
    window.display();
}

moteur.hpp :

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
#ifndef MOTEUR_HPP
#define MOTEUR_HPP
 
#include <SFML/Graphics.hpp>
#include "input.hpp"
#include "funktion.hpp"
#include "game.hpp"
 
class Moteur
{
    private :
 
    void Draw(void);
 
    public :
 
    sf::Texture t_brick, t_perso;
    sf::RenderWindow window;
    Game test;
    Input ev;
 
    Moteur(int largeur, int hauteur, std::string title);
 
    void Init(void);
    void Loop(void);
 
};
 
#endif // MOTEUR_HPP

gameobject.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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
#include "gameobject.hpp"
 
GameObject::GameObject(void)
{
 
}
 
GameObject::GameObject(int pos_x, int pos_y, int s_largeur, int s_hauteur, sf::Texture& t)
{
    x = pos_x;
    y = pos_y;
    largeur = s_largeur;
    hauteur = s_hauteur;
 
    r.width = largeur;
    r.height = hauteur;
    r.left = x;
    r.top = y;
 
    s.setTexture(t);
    s.setTextureRect(r);
    s.setPosition(x, y);
}
 
void GameObject::Init(int pos_x, int pos_y, int s_largeur, int s_hauteur, sf::Texture& t)
{
    sf::IntRect r_s;
 
    x = pos_x;
    y = pos_y;
    largeur = s_largeur;
    hauteur = s_hauteur;
 
    r.width = largeur;
    r.height = hauteur;
    r.left = x;
    r.top = y;
 
    r_s.width = largeur;
    r_s.height = hauteur;
    r_s.top = r_s.left = 0;
 
    s.setTexture(t);
    s.setTextureRect(r_s);
    s.setPosition(x, y);
}
 
void GameObject::SetPosition(int pos_x, int pos_y)
{
    r.left = x = pos_x;
    r.top  = y = pos_y;
 
    s.setPosition(x, y);
}
 
bool GameObject::IsCliked(int cursor_x, int cursor_y)
{
    return r.contains(cursor_x, cursor_y);
}
 
bool GameObject::IsCollided(GameObject& obj)
{
    return r.intersects(obj.r);
}
 
bool GameObject::IsCollided(sf::IntRect& rect1)
{
    return r.intersects(rect1);
}
 
bool GameObject::Move(int vectX, int vectY, sf::RenderWindow& w)
{
    sf::Vector2u v;
 
    v = w.getSize();
 
    int v_x = v.x, v_y = v.y;
    bool ret = false;
 
    dirX = vectX;
    dirY = vectY;
 
    x += dirX;
    y += dirY;
 
    if(x < 0)
    {
        x = 0;
        ret = true;
    }
    else if(y < 0)
    {
        y = 0;
        ret = true;
    }
    else if(x + largeur > v_x)
    {
        x = v_x - largeur;
        ret = true;
    }
    else if(y + hauteur > v_y)
    {
        y = v_y - hauteur;
        ret =  true;
    }
 
    r.left = x;
    r.top = y;
    return ret;
}
 
sf::Sprite GameObject::Draw()
{
    s.setPosition(x, y);
 
    return s;
}

gameobject.hpp :

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
#ifndef GAMEOBJECT_HPP
#define GAMEOBJECT_HPP
 
#include <SFML/Graphics.hpp>
#include <iostream>
 
class GameObject
{
    public :
 
        sf::Sprite s;
        sf::IntRect r;
        int x, y, largeur, hauteur;
        int dirX, dirY;
 
        GameObject(void);
        GameObject(int pos_x, int pos_y, int s_largeur, int s_hauteur, sf::Texture& t);
 
        void Init(int pos_x, int pos_y, int s_largeur, int s_hauteur, sf::Texture& t);
        void SetPosition(int pos_x, int pos_y);
 
        bool IsCliked(int cursor_x, int cursor_y);
        bool IsCollided(GameObject& obj);
        bool IsCollided(sf::IntRect& rect1);
        bool Move(int vectX, int vectY, sf::RenderWindow& w);
        sf::Sprite Draw(void);
};
 
#endif // GAMEOBJECT_HPP

input.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
96
97
98
99
100
101
102
103
104
105
106
107
108
#include "input.hpp"
 
Input::Input(void)
{
    Ip_Close = false;
    Ip_Esc = false;
    Ip_Left = false;
    Ip_Right = false;
    Ip_Up = false;
    Ip_Down = false;
    Ip_MLeft = false;
    Ip_Right = false;
 
    mouseX = mouseY = 0;
}
 
void Input::Update(sf::RenderWindow& w)
{
    sf::Vector2i v;
 
    v = sf::Mouse::getPosition(w);
 
    mouseX = v.x;
    mouseY = v.y;
 
    sf::Event e;
 
    while(w.pollEvent(e))
    {
        switch(e.type)
        {
            case sf::Event::Closed :
                Ip_Close = true;
            break;
 
            case sf::Event::KeyPressed :
                switch(e.key.code)
                {
                    case sf::Keyboard::Escape :
                        Ip_Esc = true;
                    break;
 
                    case sf::Keyboard::Up :
                        Ip_Up = true;
                    break;
 
                    case sf::Keyboard::Down :
                        Ip_Down = true;
                    break;
 
                    case sf::Keyboard::Left :
                        Ip_Left = true;
                    break;
 
                    case sf::Keyboard::Right :
                        Ip_Right = true;
                    break;
 
                    default :
                    break;
                }
            break;
 
            case sf::Event::MouseButtonPressed :
                switch(e.mouseButton.button)
                {
                    case sf::Mouse::Left :
                        Ip_MLeft = true;
                    break;
 
                    case sf::Mouse::Right :
                        Ip_MRight = true;
                    break;
 
                    default :
                    break;
                }
            break;
 
            case sf::Event::KeyReleased :
                switch(e.key.code)
                {
                    case sf::Keyboard::Up :
                        Ip_Up = false;
                    break;
 
                    case sf::Keyboard::Down :
                        Ip_Down = false;
                    break;
 
                    case sf::Keyboard::Left :
                        Ip_Left = false;
                    break;
 
                    case sf::Keyboard::Right :
                        Ip_Right = false;
                    break;
 
                    default :
                    break;
                }
            break;
 
            default :
            break;
        }
    }
}

input.hpp :

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
#ifndef INPUT_HPP
#define INPUT_HPP
 
#include <SFML/Graphics.hpp>
 
class Input
{
    public :
 
        bool Ip_Close, Ip_Esc;
        bool Ip_Right, Ip_Left, Ip_Up, Ip_Down;
        bool Ip_MRight, Ip_MLeft;
 
        int mouseX, mouseY;
 
        Input(void);
 
        void Update(sf::RenderWindow& w);
};
 
#endif // INPUT_HPP

funktion.hpp :

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
#ifndef FUNKTION_HPP
#define FUNKTION_HPP
 
#include <SFML/Graphics.hpp>
#include <iostream>
#include <sstream>
#include <string>
#include <cstdio>
#include <ctime>
 
int Random(int a, int b);
sf::Image LoadImage(std::string name);
std::string ConvertionIntString(int i);
std::string FilenameIncr(std::string deb, std::string extention, int nb);
int LoadFromSetInt(std::string fichier_name, std::string setting);
std::string LoadFromSetString(std::string fichier_name, std::string setting);
 
void SetTile(sf::Sprite& s, int x, int y, int srx, int sry, int largeur, int hauteur);
 
#endif // FUNKTION_HPP

funktion.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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
#include "funktion.hpp"
 
int Random(int a, int b)
{
    return rand() % (b - a) + a;
}
 
sf::Image LoadImage(std::string name)
{
    sf::Image img;
 
    if(!img.loadFromFile(name))
    {
        std::cout << "LoadImage(std::string) error" << std::endl;
    }
 
    img.createMaskFromColor(sf::Color(255, 0, 255));
 
    return img;
}
 
std::string ConvertionIntString(int i)
{
    std::string s;
    std::stringstream str_d;
 
    str_d << i;
 
    s = str_d.str();
 
    return s;
}
 
std::string FilenameIncr(std::string deb, std::string extention, int nb)
{
    std::string numbre = ConvertionIntString(nb);
 
    std::string filename = deb + numbre + extention;
 
    return filename;
}
 
int LoadFromSetInt(std::string fichier_name, std::string setting)
{
    int SetInt = 0;
    char setchar[100];
    bool  IsFinish = true;
 
    FILE *fp;
 
    fp = fopen(fichier_name.c_str(), "rb");
 
    if(fp == NULL)
    {
        std::cout << "File error" << std::endl;
    }
 
    while(IsFinish)
    {
        fscanf(fp, "%s", setchar);
 
        std::string rt_setchar(setchar);
 
        if(rt_setchar == setting)
        {
            IsFinish = false;
        }
    }
 
    fscanf(fp, "%d", &SetInt);
 
    fclose(fp);
 
    return SetInt;
}
 
std::string LoadFromSetString(std::string fichier_name, std::string setting)
{
    char setchar[100];
    bool  IsFinish = true;
 
    FILE *fp;
 
    fp = fopen(fichier_name.c_str(), "rb");
 
    if(fp == NULL)
    {
        std::cout << "File error" << std::endl;
    }
 
    while(IsFinish)
    {
        fscanf(fp, "%s", setchar);
 
        std::string rt_setchar(setchar);
 
        if(rt_setchar == setting)
        {
            IsFinish = false;
        }
    }
 
    fscanf(fp, "%s", setchar);
 
    std::string SetString(setchar);
 
    fclose(fp);
 
    return SetString;
}

elapstime.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
#include "elapsetime.hpp"
 
Elps_Time::Elps_Time(void)
{
 
}
 
void Elps_Time::Update(void)
{
    t = c.getElapsedTime();
}
 
void Elps_Time::Restart(void)
{
    c.restart();
}
 
float Elps_Time::GetTime(void)
{
    float temps_ecoule = t.asSeconds();
 
    return temps_ecoule;
}

elapstime.hpp :

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 ELAPSETIME_HPP
#define ELAPSETIME_HPP
 
#include <SFML/Graphics.hpp>
 
class Elps_Time
{
    private :
 
        sf::Clock c;
        sf::Time t;
 
    public :
 
        Elps_Time(void);
 
        void Update(void);
        void Restart(void);
 
        float GetTime(void);
};
 
#endif // ELAPSETIME_HPP

joueur.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
#include "joueur.hpp"
 
Joueur::Joueur(void)
{
    alive = true;
    is_win = false;
    gravite = false;
    onbrick = false;
    hauteur_jump = 75;
    vitesse = 5;
}
 
void Joueur::InputIG(Input& ip, sf::RenderWindow& w)
{
    if(ip.Ip_Left)
    {
        Move(-vitesse, 0, w);
    }
    else if(ip.Ip_Right)
    {
        Move(vitesse, 0, w);
    }
 
    if(ip.Ip_Up && gravite == false)
    {
        if(Move(0, -hauteur_jump, w) == true)
        {
            is_win = true;
            alive = false;
        }
 
        if(onbrick == false)
        {
            gravite = true;
        }
    }
}
 
void Joueur::Update(Input& ip, sf::RenderWindow& w)
{
    InputIG(ip, w);
 
    if(y + 48 >= 480)
    {
        gravite = false;
    }
    else if(!(y + 48 >= 480) && onbrick == false)
    {
        gravite = true;
    }
}

joueur.hpp :

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
#ifndef JOUEUR_HPP
#define JOUEUR_HPP
 
#include "gameobject.hpp"
#include "input.hpp"
 
class Joueur : public GameObject
{
    public :
 
        bool alive, is_win, gravite, onbrick;
        int hauteur_jump, vitesse;
 
        Joueur(void);
 
        void InputIG(Input& ip, sf::RenderWindow& w);
        void Update(Input& ip, sf::RenderWindow& w);
        void DrawJ(sf::RenderWindow& w);
};
 
#endif // JOUEUR_HPP

brick.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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
#include "brick.hpp"
 
Brick::Brick(void)
{
    vitesse = 48;
    alive = false;
    stop_fall = true;
    first_blood = false;
}
 
void Brick::Init(sf::Texture& t)
{
    GameObject::Init(0, 0, 48, 48, t);
}
 
void Brick::Fall(sf::RenderWindow& w, int y_max, Joueur& j)
{
    if(Move(0, vitesse, w) == true)
    {
        stop_fall = true;
    }
}
 
void Brick::Spawn(void)
{
    if(alive == false)
    {
        int x = Random(48, 432);
 
        SetPosition(x, 0);
 
        alive = true;
        stop_fall = false;
 
        timer.Restart();
    }
}
 
void Brick::Update(sf::RenderWindow& w, int y_max, Joueur& j)
{
    if(alive)
    {
        if(!stop_fall)
        {
            timer.GetTime();
 
            if(timer.GetTime() > 0.01)
            {
                Fall(w, y_max, j);
 
                timer.Restart();
            }
 
            timer.Update();
 
            if(IsCollided(j))
            {
                j.alive = false;
            }
        }
 
        sf::IntRect r;
 
        r.height = 1;
        r.width = 48;
        r.left = x;
        r.top = y;
 
        if(j.IsCollided(r))
        {
            j.gravite = false;
            j.onbrick = true;
        }
        else
        {
            j.onbrick = false;
        }
    }
}
 
void Brick::OnBrick(Brick& b, Joueur& j)
{
    if(alive == true)
    {
        sf::IntRect test_r;
 
        test_r.height = test_r.width = 48;
        test_r.left = b.x;
        test_r.top = b.y - 1;
 
        if(IsCollided(test_r))
        {
            stop_fall = true;
 
            if(IsCollided(j))
            {
                j.alive = false;
            }
        }
    }
}
 
void Brick::DrawBrick(sf::RenderWindow& w)
{
    if(alive)
    {
        w.draw(Draw());
    }
}

brick.hpp :

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
#ifndef BRICK_HPP
#define BRICK_HPP
 
#include "gameobject.hpp"
#include "funktion.hpp"
#include "elapsetime.hpp"
#include "joueur.hpp"
 
class Brick : public GameObject
{
    public :
 
        bool stop_fall, alive, first_blood;
        int vitesse;
        Elps_Time timer;
 
        Brick(void);
 
        void Init(sf::Texture& t);
        void Fall(sf::RenderWindow& w, int y_max, Joueur& j);
        void Spawn(void);
        void Update(sf::RenderWindow& w, int y_max, Joueur& j);
 
        void OnBrick(Brick& b, Joueur& j);
        void DrawBrick(sf::RenderWindow& w);
};

brickeur.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
#include "brickeur.hpp"
 
Brickeur::Brickeur(void)
{
    compteur = 0;
}
 
void Brickeur::Init(sf::Texture& t)
{
    for(int i = 0; i < 40; i++)
    {
        brk[i].Init(t);
 
        brk[i].vitesse = 5;
    }
}
 
void Brickeur::Restart(void)
{
    for(int i = 0; i < 40; i++)
    {
        brk[i].alive = false;
        brk[i].stop_fall = true;
        brk[i].SetPosition(0, 0);
 
        timer.Restart();
        compteur = 0;
    }
}
 
void Brickeur::SpawnThem(void)
{
    if(timer.GetTime() >= 2.5 && compteur < 40)
    {
        brk[compteur].Spawn();
 
        compteur ++;
 
        timer.Restart();
    }
}
 
void Brickeur::Update(sf::RenderWindow& w, Joueur& j2)
{
    SpawnThem();
 
    for(int i = 0; i < compteur; i++)
    {
        for(int j = 0; j < 40; j++)
        {
            if(j != i)
            {
                if(brk[i].stop_fall == false)
                {
                    brk[i].OnBrick(brk[j], j2);
                }
            }
        }
 
        brk[i].Update(w, 480, j2);
    }
 
    timer.Update();
}
 
void Brickeur::Draw(sf::RenderWindow& w)
{
    for(int i = 0; i < 40; i++)
    {
        brk[i].DrawBrick(w);
    }
}
 
bool Brickeur::BrickIsFinish(void)
{
    if(brk[39].alive == true)
    {
        return true;
    }
    else
    {
        return false;
    }
}

brickeur.hpp :

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 BRICKEUR_HPP
#define BRICKEUR_HPP
 
#include "brick.hpp"
#include "joueur.hpp"
 
class Brickeur
{
    public :
 
        Brick brk[40];
        Elps_Time timer;
        int compteur;
 
        Brickeur(void);
 
        void Init(sf::Texture& t);
        void Restart(void);
        void SpawnThem(void);
        void Update(sf::RenderWindow& w, Joueur& j2);
        void Draw(sf::RenderWindow& w);
 
        bool BrickIsFinish(void);
};

game.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
#include "game.hpp"
 
Game::Game(void)
{
    force_gravite = 0.6;
}
 
void Game::Init(sf::Texture& t1, sf::Texture& t2)
{
    brk_eur.Init(t1);
    j.Init(240 - 20, 480 - 48, 20, 48, t2);
}
 
void Game::Restart(void)
{
    brk_eur.Restart();
 
    j.alive = true;
    j.is_win = false;
    j.onbrick = false;
    j.SetPosition(240 - 20, 480 - 48);
}
 
void Game::Gravitation(sf::RenderWindow& w)
{
    if(j.gravite == true && j.onbrick == false)
    {
        j.Move(0, force_gravite, w);
 
        force_gravite += 0.3;
    }
    else
    {
        force_gravite = 0.6;
    }
}
 
void Game::Update(sf::RenderWindow& w, Input& ip)
{
    brk_eur.Update(w, j);
 
    j.Update(ip, w);
 
    Gravitation(w);
 
    if(j.alive == false)
    {
        Restart();
    }
}
 
void Game::Draw(sf::RenderWindow& w)
{
    brk_eur.Draw(w);
 
    j.DrawJ(w);
}

game.hpp :

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 GAME_HPP
#define GAME_HPP
 
#include "brickeur.hpp"
#include "joueur.hpp"
 
class Game
{
    public :
 
        float force_gravite;
        Brickeur brk_eur;
        Joueur j;
 
        Game(void);
 
        void Init(sf::Texture& t1, sf::Texture& t2);
        void Restart(void);
        void Gravitation(sf::RenderWindow& w);
        void Update(sf::RenderWindow& w, Input& ip);
        void Draw(sf::RenderWindow& w);
};
 
#endif // GAME_HPP

Voila, je tient à précisé que comme j'ai laissé tombé, au profit d'une restructuration global des mes conventions de programmation, je ne donnerai aucun asset.

Aussi, je pense retravaillé la plupart des partit recyclable = input, gameobject, elapstime, et d'autre qui ne sont pas présent.

Enfin, je rappel que le but de la présence de mon code n'est pas de me permettre de finir se jeu, mais de vous donnez un point de vue sur ma manière de codé avant l'ouverture de se sujet.

[LittleWhite]

Lorsque l'on vois des fichiers s'appelant "funktion", on sent qu'ils vont être fourre tout et cela reflète que tout n'est pas vraiment encore bien organisé.
ConvertionIntString() pourrait aller dans un fichier "Utils" (c'est au final un peu comme un fourre tout, mais on a changé le nom ).

Random() pourrait être une fonction inline et être statique dans une classe Random (et s'appeler GetInt()).
LoadImage pourrait aller dans une classe Image.
En théorie en C++, il ne devrait pas avoir de fonction libre (sans classe).

Dans LoadFromSetInt (quel nom étrange et pas très explicite), vous chargez le fichier à chaque fois que vous avez besoin d'une variable. Une classe Config, ou ConfigFile, pourrait vous offrir un chargement unique tout en stockant les différents paramètres.
De plus, vous utilisez FILE*, ou, le chargement de fichier C, alors que le C++ propose un nouveau mécanisme utilisant des flux pour le chargement de fichiers.
Je vois que vous passez vos paramètres std::string en copie. Pour éviter la copie (et donc de perdre du temps), vous pouvez utiliser les références constantes.

Vous n'avez pas de valeur de retour pour Game::Init(). Étrange, sachant que l'initialisation a de fortes chances d'échoués.

Code :

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

1
2
3
4
Game::Game(void)
{
    force_gravite = 0.6;
}

Vous pouvez utiliser les listes d'initialisations.
(Je vous conseille la lecture de toute la FAQ C++, on apprend énormément ainsi).

Pour la fonction Move(), je ne passerai pas toute la sf::RenderWindow, mais juste sa taille. Il n'y a pas besoin de plus, me semble t-il.

Ça manque de commentaires.

Sachant que toutes les fonctions de Brick sont conditionnés avec "isAlive()" pour ne pas tenter de simplement enlever la Brick de la liste. Ainsi, le test que vous faites à chaque début de fonctionne sera plus nécessaire.
Par contre Brick brk[40]; ne sera plus un simple tableau (en C++ cela devrait un std::array), mais peut être un std::vector.

Je pense que OnBrick pourrait être statique, vu la signature.
Ça manque de const (const-correctness).

Le nombre 40 pourrait être mis dans une variable constante, globale.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
bool Brickeur::BrickIsFinish(void)
{
    if(brk[39].alive == true)
    {
        return true;
    }
    else
    {
        return false;
    }
}

Simplifiable en

Code :

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

1
2
3
4
bool Brickeur::BrickIsFinish(void)
{
    return brk[39].alive
}

Brickeur.hpp : pas la peine de faire une classe si tout est en public (le tableau, au minimum, devrait être privé).
Input::Update : on peut faire mieux que d'utiliser le système d'événement et de vérifier pour chaque événement (utiliser le système d'état du clavier/souris/joysticks).

Voilà pour le moment. C'est un bon début, surtout si le jeu fonctionne.

[romnair]

Merci pour la réponse.

Alors, les lignes ci-dessus marché(un minimum) mais ne donné pas envie de venir faire des modifs.

Dans LoadFromSetInt (quel nom étrange et pas très explicite), vous chargez le fichier à chaque fois que vous avez besoin d'une variable. Une classe Config, ou ConfigFile, pourrait vous offrir un chargement unique tout en stockant les différents paramètres.
De plus, vous utilisez FILE*, ou, le chargement de fichier C, alors que le C++ propose un nouveau mécanisme utilisant des flux pour le chargement de fichiers.
Je vois que vous passez vos paramètres std::string en copie. Pour éviter la copie (et donc de perdre du temps), vous pouvez utiliser les références constantes.

- +1, une classe pour cette fonction et ses variantes est une très bonne idée(Yes, étrange comme nom...), une recherche sur les références constantes s'impose.

Vous n'avez pas de valeur de retour pour Game::Init(). Étrange, sachant que l'initialisation a de fortes chances d'échoués.

- Ok, mais le retour doit être écrit dans la console ou plutôt comme pour la plupart des jeux dans un fichier à part et récupérable ?

Vous pouvez utiliser les listes d'initialisations.
(Je vous conseille la lecture de toute la FAQ C++, on apprend énormément ainsi).

- Je go check !

Pour la fonction Move(), je ne passerai pas toute la sf::RenderWindow, mais juste sa taille. Il n'y a pas besoin de plus, me semble t-il.

Ça manque de commentaires.

- J'ai pris en expérience depuis, l'implémentation de commentaire est un peu plus ancré dans le codage, et la fonction Move() à bien était modifiez de la même manière que vous le suggéré(Comme personne répondé je pensé que montrer mes avancé ne servai à rien, merci encore pour ton intervention).

Sachant que toutes les fonctions de Brick sont conditionnés avec "isAlive()" pour ne pas tenter de simplement enlever la Brick de la liste. Ainsi, le test que vous faites à chaque début de fonctionne sera plus nécessaire.
Par contre Brick brk[40]; ne sera plus un simple tableau (en C++ cela devrait un std::array), mais peut être un std::vector.

- +1, manque de connaissance en C++ de ma part(trop conditionné au C).

Je pense que OnBrick pourrait être statique, vu la signature.
Ça manque de const (const-correctness).

- Encore un manque de connaissance, enfaite je ne comprend pas dans quelle cas un const est mieux(recherche time je pense).

Le nombre 40 pourrait être mis dans une variable constante, globale.

- J'en ai appris des choses pendant ces semaines, et sa sait une habitude pour les variables dont la modification peuvent impacté plusieurs endroit(l'expérience fait vraiment la diff, merci encore pour tout ton temps).

Brickeur.hpp : pas la peine de faire une classe si tout est en public (le tableau, au minimum, devrait être privé).

- +1, dorénavant je mets en privé les variables pour lesquels lors de l'utilisation de la classe leurs accès n'est pas nécessaire.

Input::Update : on peut faire mieux que d'utiliser le système d'événement et de vérifier pour chaque événement (utiliser le système d'état du clavier/souris/joysticks).

- Pas tout compris.

Voilà pour le moment. C'est un bon début, surtout si le jeu fonctionne.

- J'ai utilisé certaine parti(la majorité) pour faire un casse-brick simple, pas de grosse amélioration, à part la modif de move et l'ajout de quelque lignes de commentaire.

Merci encore.

[LittleWhite]

Bonjour,

Oui, désolé du retard. Une des choses qui me décourageait, était que j'ai du copié collé tous les codes dans des fichiers chez moi pour pouvoir explorer le projet avec un éditeur approprié. Une archive avec juste les fichiers source aurait été plus simple. Mais peu importe.

- Ok, mais le retour doit être écrit dans la console ou plutôt comme pour la plupart des jeux dans un fichier à part et récupérable ?

Non non, retour de fonction, pour que dans le main, il ne fasse pas le "Loop()" s'il y a une erreur et qu'il affiche un message à l'utilisateur.

Input::Update : on peut faire mieux que d'utiliser le système d'événement et de vérifier pour chaque événement (utiliser le système d'état du clavier/souris/joysticks).

- Pas tout compris.

La SFML vous permet de gérer les entrées avec les événements, ou une méthode que je trouve "mieux", en regardant l'état des périphériques : http://www.sfml-dev.org/documentatio...32a9c5a7ba6687

Bonne continuation.

[romnair]

Re.

Oui, désolé du retard. Une des choses qui me décourageait, était que j'ai du copié collé tous les codes dans des fichiers chez moi pour pouvoir explorer le projet avec un éditeur approprié. Une archive avec juste les fichiers source aurait été plus simple. Mais peu importe.

- Mieux vaut tard que jamais(l'intention me touche merci), désolé pour les fichiers dorénavant j'upload les sources ou les mets sur un site approprié.

La SFML vous permet de gérer les entrées avec les événements, ou une méthode que je trouve "mieux", en regardant l'état des périphériques : http://www.sfml-dev.org/documentatio...32a9c5a7ba6687

- Ah, l' avantage est que elle gère toutes les touches clavier/souris/joystick(comme tu la mentionné) sait bien sa ?

Merci encore.

[LittleWhite]

On peut uploader des .zip et autres sur le forum

Ouep, pour les touches l'avantages c'est que vous n'avez pas besoin de vérifier les événements (pas besoin d'un gros switch), ni de gérer vous mêmes des booleans pour savoir si telle ou telle touche est appuyée, il suffit d'appeler la bonne fonction SFML

[romnair]

Merci, pour ton aide. J'ai commencer les modifs je pense que je n'aurai pas beaucoup de problème.

Ouep, pour les touches l'avantages c'est que vous n'avez pas besoin de vérifier les événements (pas besoin d'un gros switch), ni de gérer vous mêmes des booleans pour savoir si telle ou telle touche est appuyée, il suffit d'appeler la bonne fonction SFML

- Sait vrai qu'un switch grossissant pour chaque évènement est assez problématique , mais bon sait en forgeant que l'ont devient forgerons. Enfaite la première fois que j'avais vu cette fonction je pensai quelle était bug , mais à vrai dire je ne me suis jamais posé et pris les infos sur la fonction.

Merci, encore je crois que maitenants je peux clore la discussion.
La prochaine sa sera pour un jeu, on verra si d'ici là j'aurai avancé, bonheur pour tous.

[LittleWhite]

Alors j'attendrai le jeu avec impatience