Débuter dans la programmation de jeux vidéo

**Dstiny** · 24/12/2014, 11h50

Je viens de lire ton code, c'est vrai que c'est beaucoup plus compréhensible et aussi plus pratique.
Sinon rien ne m'enpeche de corriger en le faisant avec le sfml mais vus que j'ai jamais vraiment utiliser de classes et de lib. C'est mieux de commencer par refaire mon pendu avec des classes non ? Et faut que j'oublie le C-Like aussi non et plutôt penser en c++ ?

**skeud** · 24/12/2014, 14h02

Oui, si tu n'as jamais utilisé de classe, je te conseil de lire quelques tuto pour connaitre:
_ Le principe de base
_ La surcharge de fonction
_ La surcharge de constructeur
_ La surcharge d'opérateur
_ L’héritage
_ Le polymorphisme
_ Et quelque design pattern comme le singleton, et la factory, qui sont très utile dans le dev jeu

.

Avec tout ça tu auras les base pour bien commencer

.

L'idéal serait que tu fasse quelques exercice et lire quelques tuto de dvp pour apprendre toutes ces notions et que tu fasse directement le pendu en SFML

. Il n'y a pas beaucoup de changement avec le pendu en ligne de console, hormis l'affichage graphique. ça se compliquera un peu en faisant ton premier jeu en SFML, à savoir le déplacement d'un personnage sur une map 2D

. Et dans ce cas, les classes sont presque obligatoire.

Sachant que le but d'une classe est de contenir des variable qui concerne une partie de ton programme. Il faut par contre impérativement respecter quelques regles:
_ Toute les variable concernant une classe sont contenu dans celle-ci
_ La classe ne doit pas modifier des variable d'une autre classe
_ Tes classe doivent uniquement dépendre des paramètre qu'on lui passe.
_ Essayer de faire en sorte que les classes soit un maximum réutilisable (c'est ce qu'on appelle la programmation modulaire).

Par exemple, la classe joueur doit s'occuper uniquement du joueur, elle ne doit pas s'occuper de son affichage ou autre.
La classe d'affichage doit uniquement d'occuper de l'affichage, pas du déplacement du joueur.

En gros une classe correspond à une fonctionnalité

.

**Dstiny** · 26/12/2014, 14h15

Salut skeud, j'ai commencer a voir de plus prés tous ça. Et je comprend pourquoi le c++ est orienter objet. De pouvoir découper son programme comme ca est vraiment bien, et ce langage me plait de plus en plus du coup XD
Je vais continuer a étudier toute les partis que tu m'as dit pour le moment et ensuite je remet a mon pendu

Et si j'ai bien compris du coup, les deux classes que tu m'as montrer je vais faire pareil et en rajouter juste pour le graphisme et adapter tous ca dans le main.cpp ?

**skeud** · 29/12/2014, 09h36

Oui c'est ça le but, l'idéal est d'avoir une classe en plus qui s'occupe de l'affichage

.

**Dstiny** · 31/12/2014, 08h11

Salut skeud. J'ai commencer a réécrire mon programme mais j'ai un petit soucis...
Pour la lecteur du fichier et prendre une ligne au hasard faut le faire depuis une classe ou pas ? Parce que j'y arrive pas :/

**skeud** · 31/12/2014, 09h33

Pas besoin de faire une classe pour ça, juste une fonction en C pour récupéré le nom du fichier et le mot, c'est de l'initialisation, en général on peut la faire directement dans le main.

L'idéal est d'avoir une classe de configuration qui contiendra toute les informations nécessaire, par exemple:
_ la taille de la fenetre d'affichage
_ le nom de l'application
_ le mot mystère
_ le nombre de vie de départ
_ les différentes images
.....

Et de faire en sorte que cette classe soit un singleton pour qu'on puisse y accéder de partout

.

**Dstiny** · 31/12/2014, 11h43

Ah ok, j'ai compris. Merci pour ta réponse

**Dstiny** · 11/01/2015, 16h01

Salut skeud
J'ai crée une classe pour récupérer les entrer au clavier de l'utilisateur sauf que elle ne fonctionne pas... ma classe arrive a récuperer se qui a etait saisie mais ensuite dans le main je n'arrive pas a le recuperer. Ca fait un moment que je suis dessus et j'arrive pas a trouver d'ou ca vient donc j'espere que tu pourras m'aider XD je t'envoie le code

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 <SFML/Graphics.hpp>
#include "fenetreDeSaisie.h"
 
#include<iostream>
#include<string>
 
sf::RenderWindow window;
std::string nnn;
FenetreDeSaisie fenetreDeSaisie(300,30,100,100,5,nnn);
 
 
int main()
{
nnn = fenetreDeSaisie.obtenirMot();
 
sf::Event event;
 
window.create(sf::VideoMode(800,600),"page");
window.setFramerateLimit(60);
window.setPosition(sf::Vector2i(250,0));
 
 
int nbDeLettre(0);
    while (window.isOpen())
    {
        if(nnn[nbDeLettre] > 0)
            std::cout << nnn << std::endl;
 
        while (window.pollEvent(event))
        {
 
            if (event.type == sf::Event::Closed)
                window.close();
 
 
 
                fenetreDeSaisie.lettreEntrer(window, event);
 
        }
 
    fenetreDeSaisie.CrerLaFenetre(fenetreDeSaisie,window);
    window.display();
    window.clear();
 
    }
}

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
 
#ifndef FENETREDESAISIE_H_INCLUDED
#define FENETREDESAISIE_H_INCLUDED
#include <SFML/Graphics.hpp>
#include <string>
#include<iostream>
 
 
class FenetreDeSaisie
{
public:
    FenetreDeSaisie(int hauteur,int largeur,int posX,int posY,int caracMax,std::string lettre);
 
    void CrerLaFenetre(FenetreDeSaisie,sf::RenderWindow& win);
    sf::Event lettreEntrer(sf::RenderWindow& win, sf::Event event);
    std::string obtenirMot();
 
private:
    int _compteur;
   int _hauteurTableau;
   int _largeurTableau;
   int _posY;
   int _posX;
   int _couleurRouge;
   int _couleurVert;
   int _couleurJaune;
   int _caracMax;
    bool _clicSurFenetre;
    char _caractere;
 
sf::RectangleShape _Rect;
sf::RectangleShape _RectEntrer;
sf::Text _boutonEntrer;
sf::RectangleShape _line;
sf::Font _Arial;
sf::Clock _temp;
std::string _letreEntrer,_mot,_lettre;
sf::Text _textEntrer;
sf::Event _event;
};
 
 
#endif // FENETREDESAISIE_H_INCLUDED

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
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
 
#include <SFML/Graphics.hpp>
#include "fenetreDeSaisie.h"
#include <iostream>
#include <string>
 
FenetreDeSaisie::FenetreDeSaisie(int largeur,int hauteur,int posX,int posY,int caracMax,std::string lettre)
{
    sf::Font Arial;
        if (!Arial.loadFromFile("arial.ttf"))
    {
        std::cout << "Erreur chargement Arial.ttf" <<std:: endl;
    }
 
    _Arial = Arial;
    sf::RectangleShape line;
    sf::Text boutonEntrer;
    sf::RectangleShape Rectangle;
    sf::RectangleShape RectangleEntrer;
    _hauteurTableau = hauteur;
    _largeurTableau = largeur;
    _posY = posY;
    _posX = posX;
    _Rect = Rectangle ;
    _RectEntrer = RectangleEntrer;
    _boutonEntrer = boutonEntrer;
    _line = line;
    _clicSurFenetre = false;
    _caracMax = caracMax;
    lettre = _letreEntrer;
 
}
 
 
void FenetreDeSaisie::CrerLaFenetre(FenetreDeSaisie, sf::RenderWindow& win)
{
 
 
_Rect.setSize(sf::Vector2f(_largeurTableau,_hauteurTableau));
_Rect.setPosition(_posX,_posY);
_Rect.setOutlineThickness(1);
_Rect.setOutlineColor(sf::Color::Blue);
 
int largeur = 40 ;
int posX = _posX + _largeurTableau;
_RectEntrer.setSize(sf::Vector2f(largeur,_hauteurTableau ));
_RectEntrer.setPosition(posX,_posY);
_RectEntrer.setFillColor(sf::Color(100,100,100));
_RectEntrer.setOutlineThickness(1);
_RectEntrer.setOutlineColor(sf::Color::Blue);
 
int posY = _posY + ((_hauteurTableau /2)-10) ;
_boutonEntrer.setPosition(posX,posY);
_boutonEntrer.setFont(_Arial);
_boutonEntrer.setString("Entrer");
_boutonEntrer.setCharacterSize(largeur / 3 );
 
 
int hauteurligne = (_hauteurTableau-10);
int posLigne = (_posX + 2);
_line.setSize(sf::Vector2f(1,hauteurligne));
_line.setPosition(posLigne,posY);
_line.setFillColor(sf::Color::Black);
 
 
 
_textEntrer.setFont(_Arial);
_textEntrer.setCharacterSize(largeur/2);
_textEntrer.setPosition(_posX,_posY);
_textEntrer.setColor(sf::Color::Green);
_textEntrer.setString(_mot);
 
 
 
    win.draw(_Rect);
    win.draw(_RectEntrer);
    win.draw(_boutonEntrer);
    win.draw(_textEntrer);
 
    if(_clicSurFenetre == true )
    {
         win.draw(_line);
    }
 
 
}
 
 
sf::Event FenetreDeSaisie::lettreEntrer(sf::RenderWindow& win, sf::Event event)
{
_event = event;
 
std::string mot;
 
int posX = _posX + _largeurTableau;
int largeur = 40;
sf::Vector2i positionSouris = sf::Mouse::getPosition(win);
 
sf::FloatRect monBouton(_posX, _posY, _largeurTableau,  _hauteurTableau);
sf::FloatRect monEntrer(posX,_posY, largeur ,_hauteurTableau);
 
        if(_event.type == sf::Event::MouseButtonPressed)
        {
        if(sf::Mouse::isButtonPressed(sf::Mouse::Left) && monBouton.contains(positionSouris.x ,positionSouris.y))
        {
 
            _clicSurFenetre = true;
        }
        else if(sf::Mouse::isButtonPressed(sf::Mouse::Left) && !monBouton.contains(positionSouris.x ,positionSouris.y) && !monEntrer.contains(positionSouris.x ,positionSouris.y) )
        _clicSurFenetre = false;
 
        if (sf::Mouse::isButtonPressed(sf::Mouse::Left) && monEntrer.contains(positionSouris.x ,positionSouris.y))
        {
                _letreEntrer = _mot;
                _mot = mot;
 
        }
        }
 
        if (_clicSurFenetre == true)
        {
 
                if(sf::Keyboard::isKeyPressed(sf::Keyboard::BackSpace)&& _mot.size()>0)
                {
                    _mot.erase(_mot.size()-1,1);
                }
                if(sf::Keyboard::isKeyPressed(sf::Keyboard::Return))
                {
                    _letreEntrer = _mot;
                    _mot = mot;
 
                }
                if(_event.type == sf::Event::TextEntered)
                {
 
                 if ((_event.text.unicode > 30 && (_event.text.unicode < 127 || _event.text.unicode > 159)))
                {
 
                    if(_mot.size() != _caracMax)
                    {
                       _mot += static_cast<char>(_event.text.unicode);
                    }
 
                }
                }
        }
        return(event);
}
 
 
std::string FenetreDeSaisie::obtenirMot()
{
  return(_letreEntrer);
}

**LittleWhite** · 12/01/2015, 22h32

Que récupère le main ? Il y a plein de trucs bancals, je trouve, notamment le fait que vous passez "nnn" au constructeur ...

**Dstiny** · 13/01/2015, 06h16

Oui je l'ai deja corriger avec quelque truc qui etait en trop. Je corrigerais mon post aussi. Il y a quoi d'autre qui ne va pas sinon ? Je m'y suis bien pris au moins pour recuperer les entrer au clavier ?

**LittleWhite** · 13/01/2015, 19h58

La technique me semble assez bien.

Le code étant mal indenté sur le forum, je ne peux pas le relire. Peu de commentaires aussi.

**LeGreg** · 14/01/2015, 00h18

Envoyé par skeud

Alors déjà plusieurs choses:
_ Tu as fait le programme en C-like, tu n'utilise pas de classe, donc ce n'est pas top..

C'est un problème de style mais chaque style est l'objet d'une convention (qui peut être choisie en début de projet).

Le langage C++ en lui-même n'oblige pas à utiliser des classes partout, c'est une partie non obligatoire du langage, tout comme les templates.

Java ou C# par exemple obligent à utiliser des classes. C++ ne le fait pas, et un programme C++ uniquement avec des fonctions classiques est valable.

Par exemple Hello World en C++ peut déclarer une fonction main(), pas dans une classe, et c'est tout.

Certes, pour apprendre le "langage", c'est important de savoir ce qu'est une classe, un template, fonctions virtuelles, statiques, namespace et les fonctions de la librairie standard etc. Mais ce n'est pas obligatoire d'utiliser TOUTES les features d'un langage au même niveau sur tous ses projets.

**Dstiny** · 14/01/2015, 18h29

LittleWhite : J'ai finis par trouver la solution et j'ai aussi enlever tout se qui était en trop et si vous me dites que m'as technique est bien ca me vas

C'est pas nécessaire que je renvoie le code du coup ?

Skeud: J'ai finis mon pendu en graphique, j'y ai aussi rajouter une fonction qui écris les lettres que j'ai déjà donner (je te donne des idée si tu veut les rajouter a l'énoncer :p) je rajouterais peut être d'autre truc aussi. Tu veut que je t'envoie le code pour me dire se que ça donne ? Et après je veut bien l'énoncer aussi pour le tetris stp

LeGreg: Je pense qu'il voulais dire que ça n’étais pas bien pour mon cas, qui débute dans la prog. Il ne m'as pas dit non plus que tout devait être classer et que c'étais obligatoire surtout pour un petit programme comme celui la.Mais je dois avouer que je trouve que mon programme a l'air plus claire et plus facile a utiliser après les avoir classer et même quand j’apporte des modification au code je mis retrouve facilement, mais bon après comme tu dis c'est surtout une question de style je pense.

**LittleWhite** · 14/01/2015, 19h52

Vous renvoyez le code (ou le projet en entier, que l'on puisse tester), si vous souhaitez que l'on vous relise et que l'on vous donne des conseils (si on voit des trucs à redire).

**Dstiny** · 14/01/2015, 22h13

ok merci

Voici mon code
main :

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
 
#include <SFML/Graphics.hpp>
#include "fenetreDeSaisie.h"
#include "MotCacher.h"
#include "AffichagePendu.h"
#include "Joueur.h"
 
#include<iostream>
#include<string>
 
sf::RenderWindow window;
 
FenetreDeSaisie fenetreDeSaisie(150,30,350,85,1);
 
MotCacher motCacher;
AffichagePendu affichage;
Joueur joueur;
 
int main()
{
sf::Event event;
 
window.create(sf::VideoMode(800,600),"page");
window.setFramerateLimit(60);
window.setPosition(sf::Vector2i(250,0));
 
 
    while (window.isOpen())
    {
            while (window.pollEvent(event))
            {
                if (event.type == sf::Event::Closed)
                    window.close();
 
                fenetreDeSaisie.lettreEntrer(window, event);
 
            }
            window.clear();
            affichage.afficherLeJeux(window);
 
                int vieJoueur = joueur.obtenirVie();
                char lettre = fenetreDeSaisie.obtenirMot()[0];
 
                motCacher.changerLettre(lettre);
 
                if(!motCacher.changerLettre(lettre) && lettre > 0 )
                    joueur.perdVie();
 
                if(!joueur.estVivant())
                    affichage.afficherLeMot(window,motCacher.obtenirMotTrouver());
 
                if(!motCacher.motEstTrouver())
                    affichage.afficherVie(window,vieJoueur);
                else
                    affichage.afficherGagner(window);
 
            affichage.afficherLesLettre(window,lettre);
            affichage.afficherMotCacher(window, motCacher.obtenirMotCacher());
            fenetreDeSaisie.CrerLaFenetre(window);
 
 
            window.display();
 
 
    }
}

motcacher.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 MOTCACHER_H_INCLUDED
#define MOTCACHER_H_INCLUDED
 
#include <string>
#include "motAleatoire.h"
 
class MotCacher
{
    public :
        MotCacher();
        ~MotCacher();
        std::string obtenirMotCacher();
        std::string obtenirMotTrouver();
        void afficherMotCacher();
        void afficherMotTrouver();
        bool changerLettre(char lettre);
        bool motEstTrouver();
 
    private :
       std::string m_motTrouver;
       std::string m_motCacher;
};
 
#endif // MOTCACHER_H_INCLUDED

motcacher.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
 
#include "motCacher.h"
 
#include <iostream>
#include <string>
#include "motAleatoire.h"
 
MotCacher::MotCacher()
{
        std::string motChanger;
        tirerMotAleatoire(motChanger);
 
        m_motTrouver = motChanger;
        int nLettre = m_motTrouver.size();
        m_motCacher.insert(0,nLettre,'_');
}
 
MotCacher::~MotCacher()
{
 
}
 
std::string MotCacher::obtenirMotCacher()
{
return (m_motCacher);
 
}
 
std::string MotCacher::obtenirMotTrouver()
{
    return (m_motTrouver);
}
 
void MotCacher::afficherMotCacher()
{
    std::cout << m_motCacher << std::endl;
}
 
void MotCacher::afficherMotTrouver()
{
    std::cout << m_motTrouver << std::endl;
}
 
bool MotCacher::changerLettre(char lettre)
{
    int i(0);
    bool renvoie = false;
 
    while (i < m_motTrouver[i])
    {
        if(m_motTrouver[i] == lettre )
        {
            m_motCacher[i] = lettre ;
            renvoie = true;
        }
        i++;
 
    }
    return (renvoie);
}
 
bool MotCacher::motEstTrouver()
{
    return (m_motCacher == m_motTrouver);
}

joueur.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
 
#ifndef JOUEUR_H_INCLUDED
#define JOUEUR_H_INCLUDED
 
#include<string>
 
class Joueur
{
   public :
        Joueur();
        ~Joueur();
 
        void perdVie();
        bool estVivant();
        int obtenirVie();
 
   private :
        int p_vie;
};
 
#endif // JOUEUR_H_INCLUDED

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
 
#include "Joueur.h"
 
#include <iostream>
#include <string>
 
 
 Joueur::Joueur()
{
    p_vie = 10;
}
 
Joueur::~Joueur()
{
 
}
 
void Joueur::perdVie()
{
    p_vie-- ;
}
 
bool Joueur::estVivant()
{
    return p_vie > 0 ;
}
 
int Joueur::obtenirVie()
{
    return(p_vie);
}

affichage.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
 
#ifndef AFFICHAGEPENDU_H_INCLUDED
#define AFFICHAGEPENDU_H_INCLUDED
#include <SFML/Graphics.hpp>
#include <iostream>
#include <string>
 
class AffichagePendu
{
public:
    AffichagePendu();
    void afficherLeJeux(sf::RenderWindow& win);
    void afficherMotCacher(sf::RenderWindow& win, std::string motCacher);
    void afficherVie(sf::RenderWindow& win, int nbVie);
    void afficherLeMot(sf::RenderWindow& win,std::string motATrouver);
    void afficherGagner(sf::RenderWindow& win);
    void afficherLesLettre(sf::RenderWindow& win,char lettre);
 
private:
    sf::Text _nomJeux,_demandeDeSaisie,_obtenirVie,_motCacher,_motATrouver,_afficherGagner,_lettreEntrer;
    sf::Font _arial;
    std::string p_viie,_lettre;
    int _nbVie;
 
};
 
#endif // AFFICHAGEPENDU_H_INCLUDED

affichage.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 <SFML/Graphics.hpp>
#include "AffichagePendu.h"
#include <iostream>
#include <string>
 
AffichagePendu::AffichagePendu()
{
 
if (!_arial.loadFromFile("arial.ttf"))
{
    std::cout << "Erreur chargement Arial.ttf" <<std:: endl;
}
 
}
 
void AffichagePendu::afficherLeJeux(sf::RenderWindow& win)
{
_nomJeux.setPosition(280,0);
_nomJeux.setFont(_arial);
_nomJeux.setString("Jeux du pendu");
_nomJeux.setCharacterSize(40);
 
win.draw(_nomJeux);
 
_demandeDeSaisie.setPosition(0,80);
_demandeDeSaisie.setFont(_arial);
_demandeDeSaisie.setString("Veuillez entrer une lettre");
 
win.draw(_demandeDeSaisie);
}
 
void AffichagePendu::afficherMotCacher(sf::RenderWindow& win, std::string motCacher)
{
_motCacher.setPosition(0,150);
_motCacher.setFont(_arial);
_motCacher.setString(motCacher);
 
win.draw(_motCacher);
}
 
void AffichagePendu::afficherVie(sf::RenderWindow& win, int nbVie)
{
_nbVie = nbVie;
switch (_nbVie)
{
case 0:
p_viie = "Vous avez perdu , Le mot etait : ";
break;
case 1:
p_viie = "Il vous reste 1 vie !";
break;
case 2:
p_viie = "Il vous reste 2 vie !";
break;
case 3:
p_viie = "Il vous reste 3 vie !";
break;
case 4:
p_viie = "Il vous reste 4 vie !";
break;
case 5:
p_viie = "Il vous reste 5 vie !";
break;
case 6:
p_viie = "Il vous reste 6 vie !";
break;
case 7:
p_viie = "Il vous reste 7 vie !";
break;
case 8:
p_viie = "Il vous reste 8 vie !";
break;
case 9:
p_viie = "Il vous reste 9 vie !";
break;
case 10:
p_viie = "Il vous reste 10 vie !";
break;
}
 
_obtenirVie.setPosition(0,250);
_obtenirVie.setFont(_arial);
_obtenirVie.setString(p_viie);
 
win.draw(_obtenirVie);
}
 
void AffichagePendu::afficherLeMot(sf::RenderWindow& win, std::string motATrouver)
{
_motATrouver.setPosition(450,250);
_motATrouver.setFont(_arial);
_motATrouver.setString(motATrouver);
 
win.draw(_motATrouver);
}
 
void AffichagePendu::afficherGagner(sf::RenderWindow& win)
{
_afficherGagner.setPosition(0,250);
_afficherGagner.setFont(_arial);
_afficherGagner.setString("Bravo,vous avez trouver le mot !!");
 
win.draw(_afficherGagner);
}
 
void AffichagePendu::afficherLesLettre(sf::RenderWindow& win,char lettre)
{
if(lettre > 0)
_lettre += lettre;
 
_lettreEntrer.setPosition(0,200);
_lettreEntrer.setFont(_arial);
_lettreEntrer.setString("Lettre que vous avez entrer : " + _lettre);
 
win.draw(_lettreEntrer);
}

fenetre d'entrer.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
31
32
 
#ifndef FENETREDESAISIE_H_INCLUDED
#define FENETREDESAISIE_H_INCLUDED
#include <SFML/Graphics.hpp>
#include <string>
#include<iostream>
 
class FenetreDeSaisie
{
public:
    FenetreDeSaisie(int hauteur,int largeur,int posX,int posY,int caracMax);
    ~FenetreDeSaisie();
 
    void CrerLaFenetre(sf::RenderWindow& win);
    sf::Event lettreEntrer(sf::RenderWindow& win,sf::Event event);
    std::string obtenirMot();
 
private:
    int _compteur;
    int _hauteurTableau;
    int _largeurTableau;
    int _posY;
    int _posX;
    int _caracMax;
    bool _clicSurFenetre,_clicSurEntrer;
 
sf::RectangleShape _Rect,_RectEntrer,_line;
sf::Text _boutonEntrer,_textEntrer;
sf::Font _Arial;
std::string _letreEntrer,_mot,_letre;
sf::Event _event;
};

fenetre d'entrer.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
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
 
#include <SFML/Graphics.hpp>
#include "fenetreDeSaisie.h"
#include <iostream>
#include <string>
 
FenetreDeSaisie::FenetreDeSaisie(int largeur,int hauteur,int posX,int posY,int caracMax)
{
    sf::Font Arial;
        if (!_Arial.loadFromFile("arial.ttf"))
    {
        std::cout << "Erreur chargement Arial.ttf" <<std:: endl;
    }
 
    _largeurTableau = largeur;
    _hauteurTableau = hauteur;
    _posX = posX;
    _posY = posY;
    _caracMax = caracMax;
 
    _clicSurFenetre = false;
    _clicSurEntrer = false;
}
 
FenetreDeSaisie::~FenetreDeSaisie()
{
 
}
 
void FenetreDeSaisie::CrerLaFenetre( sf::RenderWindow& win)
{
_Rect.setSize(sf::Vector2f(_largeurTableau,_hauteurTableau));
_Rect.setPosition(_posX,_posY);
_Rect.setOutlineThickness(1);
_Rect.setOutlineColor(sf::Color::Blue);
 
int largeur = 40 ;
int posX = _posX + _largeurTableau;
_RectEntrer.setSize(sf::Vector2f(largeur,_hauteurTableau ));
_RectEntrer.setPosition(posX,_posY);
_RectEntrer.setFillColor(sf::Color(100,100,100));
_RectEntrer.setOutlineThickness(1);
_RectEntrer.setOutlineColor(sf::Color::Blue);
 
int posY = _posY + ((_hauteurTableau /2)-10) ;
_boutonEntrer.setPosition(posX,posY);
_boutonEntrer.setFont(_Arial);
_boutonEntrer.setString("Entrer");
_boutonEntrer.setCharacterSize(largeur / 3 );
 
int hauteurligne = (_hauteurTableau-10);
int posLigne = (_posX + 2);
_line.setSize(sf::Vector2f(1,hauteurligne));
_line.setPosition(posLigne,posY);
_line.setFillColor(sf::Color::Black);
 
_textEntrer.setFont(_Arial);
_textEntrer.setCharacterSize(largeur/2);
_textEntrer.setPosition(_posX,_posY);
_textEntrer.setColor(sf::Color::Green);
_textEntrer.setString(_mot);
 
    win.draw(_Rect);
    win.draw(_RectEntrer);
    win.draw(_boutonEntrer);
    win.draw(_textEntrer);
 
    if(_clicSurFenetre == true )
    {
         win.draw(_line);
    }
}
 
sf::Event  FenetreDeSaisie::lettreEntrer(sf::RenderWindow& win, sf::Event event)
{
_event = event;
 
std::string mot;
 
int posX = _posX + _largeurTableau;
int largeur = 40;
sf::Vector2i positionSouris = sf::Mouse::getPosition(win);
 
sf::FloatRect monBouton(_posX, _posY, _largeurTableau,  _hauteurTableau);
sf::FloatRect monEntrer(posX,_posY, largeur ,_hauteurTableau);
 
        if(_event.type == sf::Event::MouseButtonPressed)
        {
        if(sf::Mouse::isButtonPressed(sf::Mouse::Left) && monBouton.contains(positionSouris.x ,positionSouris.y))
        {
            _clicSurFenetre = true;
        }
        else if(sf::Mouse::isButtonPressed(sf::Mouse::Left) && !monBouton.contains(positionSouris.x ,positionSouris.y) && !monEntrer.contains(positionSouris.x ,positionSouris.y) )
        _clicSurFenetre = false;
 
        if (sf::Mouse::isButtonPressed(sf::Mouse::Left) && monEntrer.contains(positionSouris.x ,positionSouris.y))
        {
                _clicSurEntrer = true;
                _mot = mot;
                return(_event);
        }
        }
 
        if (_clicSurFenetre == true)
        {
                if(sf::Keyboard::isKeyPressed(sf::Keyboard::BackSpace)&& _mot.size()>0)
                {
                    _mot.erase(_mot.size()-1,1);
                }
                if(sf::Keyboard::isKeyPressed(sf::Keyboard::Return))
                {
                    _clicSurEntrer = true;
                    _mot = mot;
                    return(_event);
                }
                if(_event.type == sf::Event::TextEntered)
                {
 
                 if ((_event.text.unicode > 30 && (_event.text.unicode < 127 || _event.text.unicode > 159)))
                {
                    if(_mot.size() < _caracMax)
                    {
                        _mot += static_cast<char>(_event.text.unicode);
                        _letreEntrer =_mot;
                    }
                }
                }
        }
        return(_event);
}
 
std::string FenetreDeSaisie::obtenirMot()
{
    if(_clicSurEntrer == true)
    {
        _clicSurEntrer = false;
        return(_letreEntrer );
    }
    else
        return(_letre);
}

prendre un mot au hasard .h :

Code :

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

1
2
3
4
5
6
7
8
9
 
#ifndef MOTALEATOIRE_H_INCLUDED
#define MOTALEATOIRE_H_INCLUDED
 
#include <string>
 
std::string tirerMotAleatoire(std::string& motAlea);
 
#endif // MOTALEATOIRE_H_INCLUDED

.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
 
#include "motAleatoire.h"
 
#include <iostream>
#include <string>
#include <ctime>
#include <cstdlib>
#include <cstring>
#include <fstream>
 
using namespace std;
 
string tirerMotAleatoire(string& motAlea)
{
        ifstream listeMot ("listeDeMot.txt");
        if(listeMot)
    {
        string motAleatoire(motAlea);
        int i(0),nAlea(0);
        srand(time(0));
        nAlea = rand() % 19 + 1;
 
        while(i<nAlea && getline(listeMot, motAlea ))
            {i++ ;}
return (motAleatoire);
 
    }
    else
    {
        cout << "Une erreur c'est produite, le fichier 'listeDeMot' n'as pas était trouver" << endl;
    }
}

**LittleWhite** · 10/02/2015, 14h02

Code :

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

1
2
#include<iostream>
#include<string>

Ne me semble pas utile dans le main.cpp.

Il y a des variables globales. Les variables globales en C et C++ c'est à éviter à tout prix, c'est comme le mal, la déchéance, le gouffre, la décrépitude et l’infamie.

Code :

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

void afficherLeMot(sf::RenderWindow& win,std::string motATrouver);

Afin d'éviter des copies inutiles, préférez utiliser des références constantes.

**Dstiny** · 19/02/2015, 11h11

Merci d'avoir pris le temps de lire mon code
Les variables globale se sont ceux en dehors du main ? Et pourquoi faut les eviter a tout prix XD ?
Et pour les reference et les constante c'est vrai que j'ai pris la mauvaise habitude de ne pas me demander si il faut en utiliser ou pas.. :/ je vais essayer de changer ca.

**LittleWhite** · 19/02/2015, 14h00

Les variables globales sont celles en dehors de toutes fonctions (donc en dehors du main). Il faut les éviter, car elles sont globales, donc elles ont une portée/visibilité bien plus grande que ce qu'elles devraient avoir et elle créer des bogues en programmation parallèle aussi. Et finalement, car c'est une mauvaise pratique en général.

**el_slapper** · 19/02/2015, 15h37

Le souci avec les variables globales, c'est qu'elles peuvent être modifiées à plusieurs endroit, ce qui rend le comportement du code difficile à anticiper. Certaines sont hélas inévitables, mais tant qu'on peut éviter, il faut éviter. Même pour les itérateurs. Piège classique :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
Dim I as Integer
 
Sub Proc1
    For I = 1 to 10
        Call Proc2
    Next I
End Sub
 
Sub Proc2
    I = I + 1
    Debug.Print I
End Sub

Combien de fois appelle-t-on Proc2? Mon code est basique et stupide, donc ça saute aux yeux, mais le jour ou tu auras 500 lignes entre les 2 références à I, tu vas douiller à comprendre ou est l'erreur.

**LeGreg** · 19/02/2015, 20h36

Toute variable peut être modifiée n'importe où, et ne pas avoir de variable "globale" n'exclut pas les problèmes en programmation parallèle (une variable membre peut être accédée par plusieurs threads de la même façon), mais cependant le langage définit des "portées" (scopes en Anglais) pour certaines variables. Ce sont plus des problèmes de sémantique que de fonctionnalité (sur le papier toute machine universelle de Turing peut faire les mêmes choses quel que soit son style de programmation préféré).

On va donc avoir plusieurs classes de procédures :
une où la modification et lecture de variable est implicite, une deuxième où la modification et lecture de variable est explicite.

Exemple deux fonctions :

Code :

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

1
2
void DoSomething();
ReturnType DoSomethingElse(argument1, argument2, argument3);

La première fonction n'a aucun paramètre et aucun type retourné. Il est donc certain que si elle fait quelque chose ce soit en lisant des paramètres de portée "global". Si elle affiche "hello world" sur l'écran, elle interagit avec une ressource globale qui est la sortie standard ou le système de messages Windows. Ou elle peut modifier une variable quelque part mais ce n'est pas explicité dans son prototype.

La deuxième fonction a des variables en entrée et en sortie. Donc on sait explicitement qu'elle va accéder à celles-ci en regardant le prototype et qu'elle produira un résultat de type ReturnType. Bien entendu en pratique rien n'interdit à la deuxième fonction d'avoir les mêmes effets de bords que la première fonction (afficher "hello world", modifier la même variable quelque part).

Les effets de bords sont considérés comme "sales" par les adeptes de la programmation fonctionnelle. Ils sont impératifs dans ce qu'on appelle la programmation impérative (le C/C++ ont des racines impératives même si certains concepts fonctionnels ont été introduit). La programmation objet est à mi chemin en réduisant le scope de certaines variables globales et en introduisant des scopes intermédiaires.

On aborde donc le problème des "bonnes pratiques" d’ingénierie, qui ne sont pas des lois régissant les ordinateurs mais des conventions qui sont censées faciliter le développement et la maintenance des programmes informatiques.

Le sujet est un peu trop vaste pour être couvert précisément ici.. Mais on peut parler de plusieurs guidelines utilisés dans beaucoup de gros (ou moins gros) projets modernes. Les guidelines sont l'encapsulation, l'orthogonalité, l'abstraction, etc. Pour faciliter le développement de systèmes complexes les parties du code qui ont un fort lien entre eux sont développés en "modules", ces modules ne communiquent que par des "interfaces" dont la surface est fortement réduite, et les interactions entre modules ne dépend pas (trop) de la manière dont le module a été implémenté.

Si le module table a été défini, le module composant s'engage à ne pas aller modifier les variables internes de table sans passer par l'interface (en général des fonctions ou parfois des variables publiques) que table a déclaré. Ceci pour que table puisse modifier son implémentation sans avoir à avertir composant.

Cette règle n'est évidemment pas inflexible, et dans un programme moderne les modules sont souvent beaucoup plus couplés et les ajouts/améliorations/corrections fréquentes vont devoir toucher la partie interface. Mais ce sont des guidelines qui cherchent à réduire la complexité du code.

Il est souvent dit que quel que soit la compétence d'un programmeur, le nombre de concepts avec lesquels il peut jongler en simultané est réduit et donc penser en terme de modules est important pour réduire chaque problème a un nombre limité de concepts. Cela est encore plus important quand il y a un travail en équipe (des membres de l'équipe pouvant travailler sur des modules différents en parallèle).

Pourquoi les exemples des tutoriaux de DirectX ont des variables globales alors ? Parce que ce sont des prototypes et que l'explication des concepts de rendu avec l'interface D3D ne bénéficient pas d'une encapsulation supérieure. Microsoft n'est certainement pas l'avocat d'avoir un fichier source monolithique avec uniquement des variables à portée globale pour un gros projet. Chaque programmeur ou studio de développement est donc responsable d'avoir une structure appropriée à son projet en intégrant les concepts appris dans les tutoriaux.

L'utilisation de la portée globale est inévitable dans certains cas. L'allocation de mémoire dynamique fait appel à un tas (heap) global. L'affichage sur l'écran est généralement global (mais peut-être dissimulé dans un framework type "objet", il en existe de nombreux exemples). Accès aux ressources de l'ordinateur, de variables constantes, ou même l'existence de la fonction main() en C++.

Débuter dans la programmation de jeux vidéo

Création de jeux vidéo

Discussions similaires

Partager

Partager