Discussion :

[PilloBuenaGente]

Bonjour,



Essayant de comprendre et digérer la conception en c++, j'ai voulu partir sur de bonnes bases et me suis donc lancé dans la programmation d'un jeu simple: le Morpion.zip

Je me suis inspiré de (voire plagié) certaines parties du code du livre Coder efficacement - Bonnes pratiques et erreurs à éviter (en C++).(Tant de réponses à tant de questions, merci )
J'avoue ne pas avoir encore tout saisit, d'autres lectures seront sans doute nécessaires. (non pas que ce soit mal expliqué, je ne suis pas des plus vifs..).

Je vous décris rapidement le fonctionnement:

Le programme est séparé en deux grandes parties. Game et ses composants, et le system d'entrée/sortie, en l'occurrence; Console.

Main lance game.

Game contient
--board les cases
--players les joueurs
--rules les rêgles
--interface<system>

Interface est générique et sert à charger une interface héritant des abstractions View et Controler, selon le system d'entrée/sortie définit.

View a deux fonction virtuelles pures:
--virtual void display(const Game& game) = 0;
--virtual const Input read() = 0;
Controler a une fonction viruelle pure:
--virtual void work(const Input& input, Game& game) = 0;

Console spécialise View et Controler selon le system ConsoleTag et définit le type d'interface.
ConsoleMain, ConsoleOptions et ConsoleWin sont les interfaces concrètes de Console.

ConsoleParser traite la std::string du retour clavier
ConsoleEntry stocke les choix possibles et interprète la réponse via le ConsoleParser
ConsoleWriter met en forme et affiche les informations reçues sur la console.

• Je suis conscient ne pas respecter certains aspects de SOLID notamment les contrats, mais suis-je en bonne voie ?

• Je n'arrive pas à faire d'abstraction pour ma classe Input, selon le système, on peut avoir des entrées différentes!..(peut-être en faisant des vectors de toutes sortes pour la rendre plus générique, mais c'est pas beau)

• Je ne connais pas la limite de l'over-engineering, j'ai déjà pas mal de classe pour un tout petit projet, mais le concept de single responsability aurait pu être mieux respecté avec quelques classes supplémentaire.

Suggestion et critiques sont les biens venues!

Merci d'avance!

[CodeurPlusPlus]

Décidément la toute puissance du paradigme objet engendre des horreurs. N'est-ce pas un peu compliqué pour un simple jeu de morpion ?

[PilloBuenaGente]

A ce point !?
En effet, mais si je veux garder de la flexiblilité, n'y suis-je pas contraint ?

[ternel]

Ta classe Input est peut-être trop générique, par son nom, au moins.
Une fonction par donnée attendue est raisonnable.
Position askPosition() const;
std::string askPlayerName(int number) const;
(au passage, askPlayerName pourrait demander le symbole à utiliser pour la représentation).

Concernant le nombre de classes, je ne vois rien de très anormal.

Voici comment je m'y prendrai. Ce n'est pas forcément le mieux, mais ça peut te donner un point de comparaison.

un jeu de morpion est une grille de quelques cases, où deux joueurs placent chacun leur tour un jeton, dans le but de former une ligne.

rien que pour la modélisation, tu as déjà deux ou trois classes:
la grille, le joueur, le jeton (éventuellement réductible à un identifiant de joueur dans la grille: il faudra un typedef)
Et deux fonctions déjà identifiée: placer un jeton (avec vérification) et détecter une ligne

Pour la représentation visuelle, une classe de base et une console, c'est bien.
En général, je la construit pour supporter plusieurs parties d'affilée:

• une fonction bool askNewGame()
• une fonction void start(Game*) en mentionnant que la game est une référence extérieure (éventuellement un smart pointer bien choisi)
• std::string askPlayerName(int playerId)
• une série de fonctions liées au jeu implémenté, ici Position askNextTurn(int playerId);

Libre ensuite d'implémenter une vue dans une classe séparée, mais globalement, la classe Console est un contrôleur concret (et Interface le contrôleur abstrait)

Le main devient alors :

Code :

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

1
2
3
4
5
6
7
8
//tout en pseudo code
instanciation du controleur qui va bien.
tant que controleur.askNewGame()
    game jeu ...
    controleur.start(&jeu)
    tant que jeu n'est pas fini
         jeu.act(controleur.askNextTurn(jeu.joueurCourant))
controleur.merci()

Je n'ai pas encore vu le code en détail, mais j'imagine qu'il est plutôt bien écrit, vu comment tu le décris.

[Luc Hermitte]

J'ai un vocabulaire légèrement différent de Philippe pour ce qui est des jeux (ce qui est important pour moi, c'est où est prise la décision, et non le type d'input). Et à termes, je suis persuadé que les ECS sont une meilleure solution que l'abus d'objets -- quasi inhérent à l'approche OO dans le contexte des jeux. Après je ne gère pas 50 sorties possibles, et encore moins des pièces qui ont toutes un comportement différent. A la place, j'ai 2 IA.

Bref, voici une "vieille" (i.e. sans ECS) solution à bibi: https://github.com/LucHermitte/tictactoe

[Kaamui]

Bonjour à tous,

Personnellement je trouve vos codes vraiment compliqués pour un morpion. J'ai un vieil exemple à fournir également, fait avec la SFML plutôt qu'en console. Je ne dis pas que c'est mieux ou bien codé, je le trouve déjà pas très bien conçu et encore un peu compliqué pour rien, mais c'est déjà plus simple :

Morpion.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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
 
#include <vector>
#include <SFML/Graphics.hpp>
using namespace std;
 
class Morpion
{
    enum {VIDE, CROIX, ROND} Contenu;
    vector<vector<Morpion::Contenu>> grille;
 
    sf::Texture* tGrille;
    sf::Sprite* sGrille;
 
    sf::Texture* tCroix;
    sf::Sprite* sCroix;
 
    sf::Texture* tRond;
    sf::Sprite* sRond;
 
    sf::RenderWindow* fenetre;
 
    int compteurCoups;
    bool partieTerminee;
    bool aGagne;
 
  public :
 
    Morpion();
    ~Morpion();
    void Jouer();
    void DessinerContenuGrille();
    bool ModifierGrille(Morpion::Contenu contenu, int i, int j);
    bool PartieTerminee();
    void Init();
 
    bool IA();
    std::pair<int,int> EvaluerColonnes(Morpion::Contenu c);
    std::pair<int,int> EvaluerLignes(Morpion::Contenu c);
    std::pair<int,int> EvaluerDiagonales(Morpion::Contenu c);
 
    int GetCompteurCoups() {return compteurCoups;}
    bool AGagne() {return aGagne;}
    sf::RenderWindow* GetFenetre() {return fenetre;}
 
};

Morpion.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
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
 
#include "morpion.hpp"
#include <iostream>
#include <ctime>
 
Morpion::Morpion() :
grille(3, vector<Morpion::Contenu>(3)),
tGrille(new sf::Texture()),
sGrille(new sf::Sprite()),
tCroix(new sf::Texture()),
sCroix(new sf::Sprite()),
tRond(new sf::Texture()),
sRond(new sf::Sprite()),
fenetre(new sf::RenderWindow(sf::VideoMode(300,300,32), "Titre inutile...", sf::Style::None)),
compteurCoups(9),
partieTerminee(false),
aGagne(false)
{
    grille = {{VIDE, VIDE, VIDE},{VIDE, VIDE, VIDE},{VIDE, VIDE, VIDE}};
 
    tGrille->loadFromFile("grille.png");
    sGrille->setTexture(*tGrille);
 
    tCroix->loadFromFile("croix.png");
    sCroix->setTexture(*tCroix);
 
    tRond->loadFromFile("rond.png");
    sRond->setTexture(*tRond);
 
    fenetre->setFramerateLimit(60);
    srand(time(NULL)); // initialisation de rand
 
}
 
Morpion::~Morpion()
{
    delete tGrille;
    delete tCroix;
    delete tRond;
 
    delete sGrille;
    delete sCroix;
    delete sRond;
 
    delete fenetre;
}
 
void Morpion::Jouer()
{
    while (fenetre->isOpen() && compteurCoups!= 0 && !partieTerminee)
     {
         sf::Event event;
         while (fenetre->pollEvent(event))
         {
             if (event.type == sf::Event::KeyPressed && event.key.code == sf::Keyboard::Q)
                 fenetre->close();
             if (event.type == sf::Event::MouseButtonPressed)
             {
                 if (ModifierGrille(Contenu::CROIX, event.mouseButton.x/100, event.mouseButton.y/100))
                 {
                     compteurCoups--;
                     partieTerminee = PartieTerminee();
                     if (compteurCoups > 0 && !partieTerminee)
                     {
                        compteurCoups--;
                        partieTerminee = IA();
                     }
                 }
             }
         }
 
         fenetre->clear();
 
         DessinerContenuGrille();
 
         fenetre->display();
     }
}
 
 
 
void Morpion::DessinerContenuGrille()
{
    for (int i=0; i < 3; i++)
    {
        for (int j=0; j < 3; j++)
        {
            if (grille[i].at(j) == Contenu::CROIX)
            {
                sCroix->setPosition(i*100, j*100);
                fenetre->draw(*sCroix);
            }
            else if (grille[i].at(j) == Contenu::ROND)
            {
                sRond->setPosition(i*100, j*100);
                fenetre->draw(*sRond);
            }
        }
    }
    fenetre->draw(*sGrille);
}
 
 
bool Morpion::ModifierGrille(Morpion::Contenu contenu, int i, int j)
{
    if (  i >= 0 && i <= 3 && j >= 0 && j<= 3 && grille[i].at(j) == Contenu::VIDE )
    {
        grille[i].at(j) = contenu;
        return true;
    }
    else return false;
}
 
 
bool Morpion::IA()
{
    std::pair<int,int> RAS = std::pair<int,int>(-1,-1);
    std::pair<int,int> coupAJouer = std::pair<int,int>(-1,-1);
 
    //IA teste d'abord ses chances
    if ((coupAJouer = EvaluerColonnes(Contenu::ROND)) != RAS)
    {
        ModifierGrille(Contenu::ROND, coupAJouer.first, coupAJouer.second);
        return true;//IA a gagné
    }
    else if ((coupAJouer = EvaluerLignes(Contenu::ROND)) != RAS)
    {
        ModifierGrille(Contenu::ROND, coupAJouer.first, coupAJouer.second);
        return true;//IA a gagné
    }
    else if ((coupAJouer = EvaluerDiagonales(Contenu::ROND)) != RAS)
    {
        ModifierGrille(Contenu::ROND, coupAJouer.first, coupAJouer.second);
        return true;//IA a gagné
    }
    //IA teste ensuite les dangers
    else if ((coupAJouer = EvaluerColonnes(Contenu::CROIX)) != RAS)
        ModifierGrille(Contenu::ROND, coupAJouer.first, coupAJouer.second);
    else if ((coupAJouer = EvaluerLignes(Contenu::CROIX)) != RAS)
        ModifierGrille(Contenu::ROND, coupAJouer.first, coupAJouer.second);
    else if ((coupAJouer = EvaluerDiagonales(Contenu::CROIX)) != RAS)
        ModifierGrille(Contenu::ROND, coupAJouer.first, coupAJouer.second);
    //Si toujours RAS, bah... on joue où y'a de la place, comme si il y avait une stratégie xD
    else
    {
        do
        {
            coupAJouer.first = rand()%3;
            coupAJouer.second = rand()%3;
        }while (grille[coupAJouer.first].at(coupAJouer.second) != Contenu::VIDE);
        ModifierGrille(Contenu::ROND, coupAJouer.first, coupAJouer.second);
    }
    return false;
}
 
std::pair<int,int> Morpion::EvaluerColonnes(Morpion::Contenu c)
{
    //colonne 1
    if (grille[0].at(0) == c && grille[0].at(1) == c && grille[0].at(2) == Contenu::VIDE)//case 1 et 2
    {
        //on renvoie la case à combler
        return pair<int,int>(0,2);
    }
    else if (grille[0].at(0) == c && grille[0].at(2) == c && grille[0].at(1) == Contenu::VIDE)//case 1 et 3
    {
        //on renvoie la case à combler
        return pair<int,int>(0,1);
    }
    else if (grille[0].at(1) == c && grille[0].at(2) == c && grille[0].at(0) == Contenu::VIDE)//case 2 et 3
    {
        //on renvoie la case à combler
        return pair<int,int>(0,0);
    }
    //colonne 2
    else if (grille[1].at(0) == c && grille[1].at(1) == c && grille[1].at(2) == Contenu::VIDE)//case 1 et 2
    {
        //on renvoie la case à combler
        return pair<int,int>(1,2);
    }
    else if (grille[1].at(0) == c && grille[1].at(2) == c && grille[1].at(1) == Contenu::VIDE)//case 1 et 3
    {
        //on renvoie la case à combler
        return pair<int,int>(1,1);
    }
    else if (grille[1].at(1) == c && grille[1].at(2) == c && grille[1].at(0) == Contenu::VIDE)//case 2 et 3
    {
        //on renvoie la case à combler
        return pair<int,int>(1,0);
    }
    //colonne 3
    else if (grille[2].at(0) == c && grille[2].at(1) == c && grille[2].at(2) == Contenu::VIDE)//case 1 et 2
    {
        //on renvoie la case à combler
        return pair<int,int>(2,2);
    }
    else if (grille[2].at(0) == c && grille[2].at(2) == c && grille[2].at(1) == Contenu::VIDE)//case 1 et 3
    {
        //on renvoie la case à combler
        return pair<int,int>(2,1);
    }
    else if (grille[2].at(1) == c && grille[2].at(2) == c && grille[2].at(0) == Contenu::VIDE)//case 2 et 3
    {
        //on renvoie la case à combler
        return pair<int,int>(2,0);
    }
    else
        return std::pair<int,int>(-1,-1);
}
 
std::pair<int,int> Morpion::EvaluerLignes(Morpion::Contenu c)
{
    //ligne 1
    if (grille[0].at(0) == c && grille[1].at(0) == c && grille[2].at(0) == Contenu::VIDE)//case 1 et 2
    {
        //on renvoie la case à combler
        return pair<int,int>(2,0);
    }
    else if (grille[0].at(0) == c && grille[2].at(0) == c && grille[1].at(0) == Contenu::VIDE)//case 1 et 3
    {
        //on renvoie la case à combler
        return pair<int,int>(1,0);
    }
    else if (grille[1].at(0) == c && grille[2].at(0) == c && grille[0].at(0) == Contenu::VIDE)//case 2 et 3
    {
        //on renvoie la case à combler
        return pair<int,int>(0,0);
    }
    //colonne 2
    else if (grille[0].at(1) == c && grille[1].at(1) == c && grille[2].at(1) == Contenu::VIDE)//case 1 et 2
    {
        //on renvoie la case à combler
        return pair<int,int>(2,1);
    }
    else if (grille[0].at(1) == c && grille[2].at(1) == c && grille[1].at(1) == Contenu::VIDE)//case 1 et 3
    {
        //on renvoie la case à combler
        return pair<int,int>(1,1);
    }
    else if (grille[1].at(1) == c && grille[2].at(1) == c && grille[0].at(1) == Contenu::VIDE)//case 2 et 3
    {
        //on renvoie la case à combler
        return pair<int,int>(0,1);
    }
    //colonne 3
    else if (grille[0].at(2) == c && grille[1].at(2) == c && grille[2].at(2) == Contenu::VIDE)//case 1 et 2
    {
        //on renvoie la case à combler
        return pair<int,int>(2,2);
    }
    else if (grille[0].at(2) == c && grille[2].at(2) == c && grille[1].at(2) == Contenu::VIDE)//case 1 et 3
    {
        //on renvoie la case à combler
        return pair<int,int>(1,2);
    }
    else if (grille[1].at(2) == c && grille[2].at(2) == c && grille[0].at(2) == Contenu::VIDE)//case 2 et 3
    {
        //on renvoie la case à combler
        return pair<int,int>(0,2);
    }
    else
        return std::pair<int,int>(-1,-1);
}
 
std::pair<int,int> Morpion::EvaluerDiagonales(Morpion::Contenu c)
{
    //Diagonale 1
    if (grille[0].at(0) == c && grille[1].at(1) == c && grille[2].at(2) == Contenu::VIDE)//case 1 et 2
    {
        //on renvoie la case à combler
        return pair<int,int>(2,2);
    }
    else if (grille[0].at(0) == c && grille[2].at(2) == c && grille[1].at(1) == Contenu::VIDE)//case 1 et 3
    {
        //on renvoie la case à combler
        return pair<int,int>(1,1);
    }
    else if (grille[1].at(1) == c && grille[2].at(2) == c && grille[0].at(0) == Contenu::VIDE)//case 2 et 3
    {
        //on renvoie la case à combler
        return pair<int,int>(0,0);
    }
    //Diagonale 2
    else if (grille[0].at(2) == c && grille[1].at(1) == c && grille[2].at(0) == Contenu::VIDE)//case 1 et 2
    {
        //on renvoie la case à combler
        return pair<int,int>(2,0);
    }
    else if (grille[0].at(2) == c && grille[2].at(0) == c && grille[1].at(1) == Contenu::VIDE)//case 1 et 3
    {
        //on renvoie la case à combler
        return pair<int,int>(1,1);
    }
    else if (grille[1].at(1) == c && grille[2].at(0) == c && grille[0].at(2) == Contenu::VIDE)//case 2 et 3
    {
        //on renvoie la case à combler
        return pair<int,int>(0,2);
    }
    else
       return std::pair<int,int>(-1,-1);
}
 
bool Morpion::PartieTerminee()
{
    //on vérifie en colonne en en ligne si on a pas gagné...
    for (int i = 0; i < 3; i++)
    {
        if ( grille[i].at(0) == Contenu::CROIX && grille[i].at(1) == Contenu::CROIX && grille[i].at(2) == Contenu::CROIX )
            return (aGagne = true);
 
 
        if ( grille[0].at(i) == Contenu::CROIX && grille[1].at(i) == Contenu::CROIX && grille[2].at(i) == Contenu::CROIX )
            return (aGagne = true);
    }
    //...puis les diagonales
    if ( grille[0].at(0) == Contenu::CROIX && grille[1].at(1) == Contenu::CROIX && grille[2].at(2) == Contenu::CROIX )
        return (aGagne = true);
    if ( grille[0].at(2) == Contenu::CROIX && grille[1].at(1) == Contenu::CROIX && grille[2].at(0) == Contenu::CROIX )
        return (aGagne = true);
 
    return false;
}
 
 
void Morpion::Init()
{
    grille = {{VIDE, VIDE, VIDE},{VIDE, VIDE, VIDE},{VIDE, VIDE, VIDE}};
    partieTerminee = false;
    aGagne = false;
    compteurCoups = 9;
 
}

Lanceur.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
 
#include "morpion.hpp"
 
class Lanceur
{
    sf::Texture* tGagne;
    sf::Sprite* sGagne;
 
    sf::Texture* tPerdu;
    sf::Sprite* sPerdu;
 
    sf::Texture* tNul;
    sf::Sprite* sNul;
 
    sf::Texture* tRejouer;
    sf::Sprite* sRejouer;
 
    bool rejouer;
    bool choixFait;
 
    Morpion* m;
 
  public :
        Lanceur();
        void GererPartie();
 
 
};

Lanceur.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
 
#include "lanceur.hpp"
 
 
Lanceur::Lanceur() :
tGagne(new sf::Texture()),
sGagne(new sf::Sprite()),
tPerdu(new sf::Texture()),
sPerdu(new sf::Sprite()),
tNul(new sf::Texture()),
sNul(new sf::Sprite()),
tRejouer(new sf::Texture()),
sRejouer(new sf::Sprite()),
rejouer(true),
choixFait(false),
m(new Morpion())
{
    tGagne->loadFromFile("Gagne.png");
    sGagne->setTexture(*tGagne);
 
    tPerdu->loadFromFile("Perdu.png");
    sPerdu->setTexture(*tPerdu);
 
    tNul->loadFromFile("Egalite.png");
    sNul->setTexture(*tNul);
 
    tRejouer->loadFromFile("Rejouer.png");
    sRejouer->setTexture(*tRejouer);
 
}
 
 
 
void Lanceur::GererPartie()
{
    while(rejouer)
    {
        rejouer = false;//on remet rejouer à false maintenant qu'on est entré dans la boucle
        m->Jouer();
 
        //partie terminée...
        m->GetFenetre()->clear();
        m->DessinerContenuGrille();
 
        if (m->GetCompteurCoups() == 0)
            m->GetFenetre()->draw(*sNul);
        else if (m->AGagne())
            m->GetFenetre()->draw(*sGagne);
        else
            m->GetFenetre()->draw(*sPerdu);
 
        m->GetFenetre()->display();
 
 
        sf::Time t = sf::seconds(2);
        sf::sleep(t);
 
 
         while (m->GetFenetre()->isOpen() && !choixFait)
         {
             sf::Event event;
             while (m->GetFenetre()->pollEvent(event))
             {
                 if (event.type == sf::Event::KeyPressed && event.key.code == sf::Keyboard::Q)
                     m->GetFenetre()->close();
                 if (event.type == sf::Event::MouseButtonPressed && event.mouseButton.button == sf::Mouse::Button::Left)
                 {
                     if ((event.mouseButton.x <= 150) && (event.mouseButton.y > 150))
                     {
                        //on veut rejouer
                        rejouer = true;
                        choixFait = true;
                     }
                     else if ((event.mouseButton.x > 150) && (event.mouseButton.y > 150))
                     {
                         //on ne veut pas rejouer
                         rejouer = false;
                         choixFait = true;
                     }
                 }
                 m->GetFenetre()->clear();
                 m->DessinerContenuGrille();
                 m->GetFenetre()->draw(*sRejouer);
                 m->GetFenetre()->display();
             }
         }
        if (rejouer)
        {
            m->Init();
            choixFait = false;
            t = sf::milliseconds(500);
            sf::sleep(t);
 
        }
        //byebye...
    }
}

main.cpp

Code :

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

1
2
3
4
5
6
7
8
9
10
11
#include <iostream>
#include "lanceur.hpp"
 
using namespace std;
 
int main()
{
    Lanceur morpion;
    morpion.GererPartie();
    return 0;
}

[Luc Hermitte]

Tu ne veux pas utiliser at(). At(), c'est quand on ne sait pas ce que l'on fait
Tu ne veux pas de vecteur de vecteur. Pas efficace, et puis si tu te forces à rester en 3x3, les tableaux statiques sont très bien.
Tu ne veux pas de pointeurs bruts/nus non plus.
(et le code n'est pas const-correct)

[Kaamui]

J'ai précisé que c'était vieux et mal foutu (j'ai commencé le C++ en 2010, ce code doit dater de 2012 (et avait été fait en 5h dans une espèce de "gamejam" avec des potes), je ne savais effectivement pas ce que je faisais).

T'es-tu senti agressé par mes propos (moi oui mais peut-être ai-je tort) ? Où sommes-nous là pour faire un concours futile ? Parce que pour ce qui est d'aider l'OP dans l’appréhension du C++, je penses que ton code qui est surement parfait^^ est néanmoins illisible et incompréhensible. Je ne sais peut-être pas ce que je fait, mais je sais ce que j'essaie de faire : aider l'OP. Avant toute autre chose...

[Luc Hermitte]

Ton code n'est pas plus compréhensible avec la SFML qui vient parasiter l'essence du jeu tu sais ?. Quand à mon code, il est illisible car commenté avec Doxygen. C'est sûr, ça rajoute du bruit. De plus, ce n'est pas un morpion, mais un tic-tac-toe à grille de taille variable, avec deux vraies IA derrières. C'est de fait pas exactement comparable en termes de complexité requise. Mais il est vrai que l'OP est parti sur un morpion, mais il l'a voulu générique/extensible.

Après je précise ce qui ne va pas dedans, comme je précise toujours quand je vois des mauvaises pratiques indiquées en exemple ou autre à d'autres intervenants.

----
@ PilloBuenaGente
a- Ne retourne pas des valeurs const. Dans le passé, cette feinte était intéressante, aujourd'hui (C++11) elle va devenir contreproductive.
-> ne renvoie pas du const en sortie de Coord + Coord, ni de Coord <= Coord, ...

Ou alors il te manque parfois des références
-> Coord const& Board::size() const
-> Coord const& Coord::operator[](...) const

b- Evite de préfixer par des tirets-bas. Cf la FAQ pour le pourquoi on déconseille cette pratique.

c- Pareil, tu ne veux pas utiliser std::vector::at(). La programmation défensive, c'est quand on ne sait pas où on va -- ou que les systèmes sont trop compliqués et que l'on ne peut pas maitriser la chose ni faire l'effort de vérifier les préconditions au niveau où cela devrait se faire. Cf le chapitre du livre sur la PpC, ou ma prose.

d- Board::resize() ne devrait pas exister. Là, tu permets à un plateau d'exister dans un état où il n'est pas utilisable. A la sortie du constructeur il devra avoir sa taille finale.

e- Coord + Coord n'a pas de sens. Une coordonnée sert sémantiquement à identifier une position dans un référentiel. La différence entre deux coordonnées sera un vecteur -- j'ai appelé ça delta dans ma solution.

f- Coord::begin() et end() me perturbent. Je n'ai pas pris le temps de chercher où ils intervenaient, ni s'ils y étaient pertinents sous ce nom.

g- Tes enums devraient être des enums class (vu que tu utilises déjà le C++ dans ton code)

[ternel]

Doucement.
Luc Hermitte souligne les erreurs de réalisation de ton code, justement pour permettre à PilloBuenaGente (et à tout lecteur un peu débutant) de comprendre ce qui n'est pas idéal.

Il l'a certes dit un peu sèchement, mais d'un autre coté, tu es arrivé en disant

Personnellement je trouve vos codes vraiment compliqués pour un morpion

Et son code est assez clair, mais utilise des classes utiles dédiées.
Par exemple, tu n'a pas de classe de grille, proposant un opérateur d'indexation.

Ma proposition est simple. Si, si.
Le minimum de classe pour séparer les fonctionnalités.
Et une représentation des données directement tirée de ce qu'on représente (ce qu'on appelle le métier...)

ps: zut, doublé

[PilloBuenaGente]

Ta classe Input est peut-être trop générique, par son nom, au moins.
Une fonction par donnée attendue est raisonnable.
Position askPosition() const;
std::string askPlayerName(int number) const;

Il me faudra un getter/setter pour chacune des valeurs.

(au passage, askPlayerName pourrait demander le symbole à utiliser pour la représentation).

Si on passe par une image pour la représentation, la fonction risque de devenir inutile.

Concernant le nombre de classes, je ne vois rien de très anormal.

Me voilà rassuré !
Mis à part la prochaine, la suite semble correspondre plus ou moins à ce que j'ai fait.

une série de fonctions liées au jeu implémenté, ici Position askNextTurn(int playerId);

Code :

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

1
2
3
4
5
6
7
8
//tout en pseudo code
instanciation du controleur qui va bien.
tant que controleur.askNewGame()
    game jeu ...
    controleur.start(&jeu)
    tant que jeu n'est pas fini
         jeu.act(controleur.askNextTurn(jeu.joueurCourant))
controleur.merci()

Je garde en tête cette approche interessante. askNextTurn semble être une fonction centrale au jeu. Ce qui en découle se devrait d'être plus solide.

Le minimum de classe pour séparer les fonctionnalités.
Et une représentation des données directement tirée de ce qu'on représente (ce qu'on appelle le métier...)

Je pense devoir bosser là dessus !

Et à termes, je suis persuadé que les ECS sont une meilleure solution que l'abus d'objets -- quasi inhérent à l'approche OO dans le contexte des jeux.

J'avais déjà jeté un œil il y a un moment sur le ECS, je suis peut être aujourd'hui plus apte à comprendre le principe.

g- Tes enums devraient être des enums class (vu que tu utilises déjà le C++ dans ton code)

J'ai oublié de le changer avant de le poster, désolé.
Le fait d'utiliser l'enum classique au lieu de enum class vient juste du fait que j'utilise code::blocks et suis attaché au code completion..
Peut-on déroger à certaines rêgles si le code devient plus lisible? Le coord[X] me plait mieux que coord[CordType::X] par exemple.

b- Evite de préfixer par des tirets-bas. Cf la FAQ pour le pourquoi on déconseille cette pratique.

Pareil pour ceci, le '_' sépare les objets privés et publiques dans la code completion.. Sans doute pas une bonne idée.. (J'ai lu qu'apparemment on pouvait quand même utiliser '_' suivi d'une lettre en minuscule)(«_Type» est une bourde).

f- Coord::begin() et end() me perturbent. Je n'ai pas pris le temps de chercher où ils intervenaient, ni s'ils y étaient pertinents sous ce nom.

Les opérators ne sont plus reliés à rien. (comme deux trois trucs que je viens de croiser) Ils m'ont servi à un moment pour du réduire une fonction avec un range-based loop. (Un utilitaire pour repérer le code ne servant pas/plus?)

J'en retiens beaucoup des autres remarques,(acde), merci pour les conseils !

Merci aussi pour vos codes, plein de choses sont à puiser, je vous volerais sans doute quelques idées ;D

[Luc Hermitte]

Pour setter/getter, je te renvoie au §8.1 du livre.

Je ne suis pas passé non plus aux enums class car il leur manque des fonctionnalités par rapport à ce que je peux faire avec une imbrication struct { enum{} }. Mais au final, je garde toujours le scoping. Si j'en parle, c'est que je me souviens avoir relevé un bug dans une des premières versions du jeu d'échec qui aurait été intercepté avec une enum class. ^^

[PilloBuenaGente]

Pour setter/getter, je te renvoie au §8.1 du livre.

C'est pourquoi je n'avais pas fait cela, et que le problème de l'Input persiste. Mais comme l'a fait remarquer Leternel, c'est sans doute l'existence ou la forme de la classe Input qui est remis en cause. J'ai un peut honte mais je me dis là, que la réponse est peut être dans une partie du code du jeu d'échec que je n'aurais su comprendre..

Si j'en parle, c'est que je me souviens avoir relevé un bug dans une des premières versions du jeu d'échec qui aurait été intercepté avec une enum class.

Les forts typage semblent vraiment reduire les erreurs possibles.

[ternel]

En fait, plus le typage sera fort, plus le compilateur pourra râler facilement.
Les erreurs sont toujours autant possibles, mais comme elles sont rejetée, tu ne peux que les corriger.

Et en toute situation, si le compilateur soulève un problème de typage, il ne faut jamais alléger le type (enlever un const, un unsigned ou autre)