Discussion :

[DarKaa]

Bonjour a tous,

J'ai comme projet de realiser un programme mettant en application des algorithmes genetiques pour resoudre le probleme des n-reines.

J'ai donc fais tous les menus et formulaire de recuperation de paramettre en Qt (QMainWindow, QWidget, QLabel, etc..)

Arrive maintenant le probleme de la creation de lechiquier. J'ai deja trouver quelques indications de la part de yan et johnlamericain concernant des QGraphicsView, QGraphicsScene, QGraphicsRectItem, QGraphicsCaseItem. Je m'y suis penche :
Lorsque je souhaite afficher mon echiquier j'ai instancier un objet (a moi) heritant de QMainWindow. A l'interieur de cet objet j'ai un QGraphicsView et un QGraphicsScene. Avec la methode addRect de QGraphicsScene j'ai trace mes carres. Le truc c'est que pour un echiquier de 8 cases ca marche mais si je dois resoudre le probleme des 12 reines j'ai un probleme, je n'arrive pas a affichier plus de 10 carres par ligne, cela mm si jai une scroll barre sur le cote.. Je n'arrive meme pas a agrandir la taille de mon echiquier (que se soit par la methode resize de ma QMainWindow ou par le constructeur de ma QGraphicsScene)

Je pense que je dois mal utiliser ces objets c'est pour cela que je sollicite votre aide pour m'aiguiller.

Merci d'avance.

[koala01]

Salut,

Comme d'habitude, si on avait un minimum de code, cela pourrait nous servir énormément

Mais, ceci dit, il faut savoir que ta vue "graphique" n'est et et ne sera jamais rien de plus "qu'une des possibilités dont tu disposes pour afficher des informations".

En effet, même si je n'ai pas vraiment d'idée à proposer pour ce faire, tu pourrais très bien afficher toutes les informations sous la forme d'une vue tabulaire ou sous la forme d'un arbre

Tout cela pour dire que ton échiquier, les cases qui le composent, les reines et leurs positions respectives sur l'échiquier font réellement partie de tes données "métier".

A partir de là, il faut prévoir les classes qui permettent de gérer ces différentes informations (au niveau du métier), et les placer dans un modèle qui représente les différentes relations qui peuvent exister

Une fois que cela est fait, tu peux, effectivement, t'attaquer au problème de l'affichage sous une forme ou une autre.

Et c'est là que vont intervenir tes QGraphicsView, QGraphicsScene et autres QGraphicsItems

En effet, tu vas donner ta QGraphicsScene à ta QGraphicsView, et, d'un autre coté, tu vas créer l'ensemble des case de l'échiquier pour les donner à ta scène, et, pour chaque reine que tu auras, tu la créeras aussi (il faut bien, hein ) et tu te basera sur le modèle pour récupérer le QGraphicsItem qui correspond à la case sur laquelle elle se trouve afin de l'indiquer comme étant son parent avec la fonction setParentItem()

Ainsi, on pourrait envisager une partie métier proche des classes

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
 
enum Color
{
    black ,
    white
};
class Case
{
    public:
        Case(int line, int column):line_(line),column_(column){}
        int id() const{return line_*8 + column_;}
        int line() const{return line_;}
        int column() const{return column_;}
        Color color() const{return id() % 2;} 
    private:
        int line_;
        int column_;
}
class Queen
{
    public:
        Queen(int id, Color color):id_(id), color_(color){}
        int id() const{return id_;}
        Color color() const{return color_;}
    private:
        int id_;
        Color color_;
};
case ChessPlate
{
    public:
        ChessPlate()
        {
              cases_.reserve(8*8);
             for (int line = 0;line<8; ++line)
             {
                 for(int column = 0;columns <8; ++column)
                 {
                      cases_.push_back(Case(line, column));
                 }
             } 
        }
};

Et, pour gérer la position des reines, tu pourrais avoir une classe proche de
class Position

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
{
    /** en interne, on gère l'identifiant d'une reine et celui de la case sur
       * laquelle elle se trouve ;)
       */
    struct Relation
    {
        Relation(int queen, int case):queenId(queen),caseId(case){}
        int queenId;
        int caseId;
    };
    /* et on place le tout dans un vecteur, par facilité ;)
    typedef std::vector<Relation> collection;
    public:
        /* l'utilisateur n'a meme pas besoin de connaitre la structure que l'on
         * utilise... il faut juste qu'il puisse 
         *    1- indiquer de retirer une reine, sur base de son identifiant
         *    2- indiquer de rajouter une reine sur une case donnée sur base 
         *        de leurs identifiants respectifs
         *    3- récupérer l'identifiant d'une reine sur base de celui d'une case
         *    4- récupérer l'identifiant d'une case sur base de celui d'une reine
         *    5- éventuellement indiquer le déplacement d'une reine 
         */
        void addQueenOnCase(int queen, int case)
            { relations_.push_back(Relation(queen, case));}
        /** renvoie l'identifiant de la reine si on trouve l'identifiant de la case,
           * autrement, renvoie std::numeric_limits::max<int>() pour indiquer
           * que la case est libre ;)
           */
        int queenId(int case) const
        {
             /* syntaxe C++11 :D */
             for( auto rel : relations_)
             {
                  if(rel.caseId == case)
                      return rel.queenId;
             }
             return std::numeric_limits::max<int>();
        } 
 
        /** renvoie l'identifiant de la case si on trouve l'identifiant de la reine,
           * autrement, renvoie std::numeric_limits::max<int>() pour indiquer
           * que la indiquer que la reine n'est plus sur l'échiquier ;)
           */
        int caseId(int queen) const
        {
             /* syntaxe C++11 :D */
             for( auto & rel : relations_)
             {
                  if(rel.queenId == queen)
                      return rel.caseId;
             }
             return std::numeric_limits::max<int>();
        } 
        void removeQueen(int queen)
        {
            for (auto& it : relations_)
            {
                if( (it.queenId == queen)
                    relations_.erase(
                        std::remove(relations_.begin(), relation.end(),it) );
            }
        }
        void moveQueen(int queen, int newCase)
        {
            removeQueen(queen);
            addQueenOnCase(queen, newCase);
        }
    private:
        collection relations_;
};

qui te permet, au travers de ton modèle, de récupérer l'identifiant (et donc le QGraphicsItem équivalent) de la case sur laquelle se trouve une reine donnée, et qui te permet donc, si elle se trouve effectivement sur une case "valide" de l'afficher, et d'indiquer quelle case est son parent

[DarKaa]

Merci beaucoup pour ta reponse, ca m'a conforte dans la gestion des "acteurs"
Neanmoins c'est plutot pour le cote technique que j'ai un probleme . Comme tu (dites moi si le tutoiement est possible) l'as demande je vais poster du code (que j'ai minimiser au maximum )
main.cpp (rien de fou)

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
#include <QApplication>
#include "test.h"
#include <QtGui>
 
int main(int argc, char *argv[])
{
  QApplication app(argc, argv);
 
  Test *lol = new Test();
 
  return app.exec();
}

test.h (la aussi..)

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
#include <QGraphicsScene>
#include <QGraphicsView>
#include <QDialog>
#include <QMainWindow>
 
class Test : public QMainWindow
{
 public:
  Test();
  ~Test();
 private:
};

test.cpp (voila l'endroit ou je test mais mal..)

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
 
#include "test.h"
#include <iostream>
 
#define N 3 //nombre de reine que je recupere via un formulaire
 
Test::Test() : QMainWindow()
{
//Zone de trouble
  this->setFixedSize(800, 600); // Marche pas..
  scene = new QGraphicsScene(); //Une fois la logique comprise je mettrai certains objets dans la class Test
  vue = new QGraphicsView(scene);
  vue->showMaximized();
  QBrush bbrush(Qt::black);
  QBrush wbrush(Qt::white);
  QPen pen;
 
//Algorithme d'echiquier
  int i;
  int j = 0; 
  while (j < N)
    {
      i = 0;
      while (i < N)
        {
          if (i % 2 == 0)
            {
              if (j % 2 == 0)
		scene->addRect(i * 100, j * 100, 100, 100, pen, bbrush);
              else
                scene->addRect(i * 100, j * 100, 100, 100, pen, wbrush);
            }
          else
            {
              if (j % 2 == 1)
		scene->addRect(i * 100, j * 100, 100, 100, pen, bbrush);
              else
                scene->addRect(i * 100, j * 100, 100, 100, pen, wbrush);
            }
          i++;
	}
      j++;
    } 
   vue->show();
}
 
Test::~Test()
{
 
}

Voila, alors deja ce code marche bien. Ce que je souhaite c'est que l'echiquier s'affiche dans une fenetre dont je puisse changer les dimension et se comporte comme un widget que je peux mettre dans un layout pour pouvoir afficher autre chose sinon je devrai ouvrir une autre fenetre.

EDIT : algo corrige

[ness522]

regardes du côté du dernier défi Qt, il s'agit d'un jeu d'échecs justement, tu auras plein de discussions et de programmes exemples