Discussion :

[Caxton]

Bonjour,

Hier, je me suis décidé à reprendre le principe d'une application. Pas que j'en abandonne totalement mes projets !

J'ai fait une sorte de lanceur de Dé. Jusque là, c'est assez facile.

Pièce jointe 123656

J'ai trouver le code qui permettrait de lancer une classe qui elle se chargerais de fournir un résultat aléatoire. Et d'ailleurs, je me prépare à en écrire son algorithme.

Code dans le slot du bouton, qui, pour le moment ne sert qu'à démontrer que la sélection se fait correctement.

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
 
//Slot Bouton Lancer les Dés.
void MainWindow::on_pushButton_clicked()
{
    //Si c'est le dé 4 qui est sélectionné
    if(ui->radioButton_4->isChecked()) {
        //Debug -> Afficher 4
        ui->lcdNumber->display(4);
    }
 
    //Si c'est le dé 6 qui est sélectionné
    if(ui->radioButton_6->isChecked()) {
        //Debug -> Afficher 6
        ui->lcdNumber->display(6);
    }
 
    //Si c'est le dé 8 qui est sélectionné
    if(ui->radioButton_8->isChecked()) {
        //Debug -> Afficher 8
        ui->lcdNumber->display(8);
    }
 
    //Si c'est le dé 10 qui est sélectionné
    if(ui->radioButton_10->isChecked()) {
        //Debug -> Afficher 10
        ui->lcdNumber->display(10);
    }
 
    //Si c'est le dé 12 qui est sélectionné
    if(ui->radioButton_12->isChecked()) {
        //Debug -> Afficher 12
        ui->lcdNumber->display(12);
    }
 
    //Si c'est le dé 20 qui est sélectionné
    if(ui->radioButton_20->isChecked()) {
        //Debug -> Afficher 20
        ui->lcdNumber->display(20);
    }
 
    //Si c'est le dé 100 qui est sélectionné
    if(ui->radioButton_100->isChecked()) {
        //Debug -> Afficher 4
        ui->lcdNumber->display(100);
    }
}

Voilà ce que je compte faire. A la suite de tout ces if, j'aurais fait une sorte d'appel de classe tel que:

Code :

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

1
2
3
4
5
 
dice = new dice();           //Créer un objet dice
dice.setFaces(int faces);  //Initialise le nombre de faces
dice.throw();                  //Lancer les dés
ui->lcdNumber->display(dice.out());

Dans ma classe, il faudra un constructeur. Il initialisera le nombre d'affichage intermédiaire tel que:

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
 
//Conctructeur
   //Initialiser 6 affichages intermédiaire
 
//setFace (int faces)
   //Place le nombre de face dans une variable
 
//throw ()
   //boucle for int i = int 6 affichages intermédiaire
      //Aléatoire entre 1 et int faces
      //Afficher sur le lcdNumber->display(résiltat intermédiaire)
      //Refresh (repaint ?)
      //Attendre 1 seconde
      //Boucler
 
   //Aléatoire entre 1 et int faces
   //Placer dans une variable int out
 
//out()
   //Return int out

Je pense que j'ai la base théorique. Il ne me reste plus, si je ne me suis pas tromper qu'à implémenter cela

[Caxton]

Plop !

Alors, dans un souci de clarté... j'ai commencer ma classe externe. Un fichier dice.h et un fichier dice.cpp.

Voyons ce que j'ai fait et ce qui reste à faire

Au niveau de dice.h j'ai fait ceci:

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 DICE_H
#define DICE_H
 
#include <QMainWindow>
 
class dice : public QMainWindow
{
    Q_OBJECT
public:
    explicit dice(QWidget *parent = 0);
    void setFaces(int faces);               //Déclaration de la méthode setFaces
    void throwDice();                       //Opère un lancement de dé
 
private:
    int nbAff;                              //Nombre d'affichage intermédiaire
    int F;                                  //Nombre de face dans la classe
 
    int randN(int n);                       //Methode permettant de retourner un nombre aléatoire entre 1 et n
 
signals:
 
public slots:
 
};
 
#endif // DICE_H

Et au niveau de dice.cpp cela:

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
 
#include "dice.h"
#include <qDebug>
#include <qglobal.h>
 
//Conctructeur de la classe dice
dice::dice(QWidget *parent) :
    QMainWindow(parent)
{
    nbAff = 6;  //Initialise le nombre d'affichage intermédiaire
}
 
//Setter le nombre de faces
void dice::setFaces(int faces)
{
    F = faces;  //Initialise le nombre de face avec ce qui est setté
}
 
//Lancer les dés
void dice::throwDice()
{
    //Boucler pour x affichages intermédiaires
    for (int i = 1; i < nbAff; i++)
    {
        //Lancer un rand
        //Afficher (mainwindow : ui->lcdNumber->display(resultatRandIntermediaire); donc en dehors de la classe
        //Attendre 1seconde (sleep(1000) ?) 
 
        qDebug() << "Attention" << i;
    }
 
 
 
    qDebug() << "NB Faces" << F << "Random" << randN(F);
}
 
//Random pour n faces
int dice::randN(int n)
{
    int partSize = 1 + (n == RAND_MAX ? 0 : (RAND_MAX - n) / (n + 1));
    int maxUserFull = partSize * n + (partSize -1);
    int draw;
 
    do
    {
        draw = rand();
    }
    while (draw > maxUserFull);
 
    return (draw / partSize) + 1;
}
 
//Mon code pour setter
//qDebug() << faces;

Enfin l'appel de fonction dans le slot du mainwindow.cpp qui permet de tester sur l'appuie d'un bouton

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
 
//Slot Bouton Lancer les Dés.
void MainWindow::on_pushButton_clicked()
{
    int nbFaces;  //Le nombres de faces
 
    //Si c'est le dé 4 qui est sélectionné
    if(ui->radioButton_4->isChecked())
    {
        nbFaces = 4;    //Charger un nombre de face
    }
 
    //Si c'est le dé 6 qui est sélectionné
    if(ui->radioButton_6->isChecked())
    {
        nbFaces = 6;    //Charger un nombre de face
    }
 
    //Si c'est le dé 8 qui est sélectionné
    if(ui->radioButton_8->isChecked())
    {
        nbFaces = 8;    //Charger un nombre de face
    }
 
    //Si c'est le dé 10 qui est sélectionné
    if(ui->radioButton_10->isChecked())
    {
        nbFaces = 10;    //Charger un nombre de face
    }
 
    //Si c'est le dé 12 qui est sélectionné
    if(ui->radioButton_12->isChecked())
    {
        nbFaces = 12;    //Charger un nombre de face
    }
 
    //Si c'est le dé 20 qui est sélectionné
    if(ui->radioButton_20->isChecked())
    {
        nbFaces = 20;    //Charger un nombre de face
    }
 
    //Si c'est le dé 100 qui est sélectionné
    if(ui->radioButton_100->isChecked())
    {
        nbFaces = 21;    //Charger un nombre de face
    }
 
    dice D;                 //Initialisation d'un Dés D
    D.setFaces(nbFaces);    //Set le nombre de face du dé à jetter
    D.throwDice();          //Jetter les dés
 
}

Un grand merci à WinJerome pour son aide sur le randum disponible en VP: http://c.developpez.com/faq/?page=alea#RANDOM_runif_a_b

J'ai juste eu à modifier et a débugger avec EpiTouille. A la fin je rajoute +1 car je ne veux pas tomber à "0".

Ensuite, il reste, pour moi un mystère que je pense contourner. J'ai dans ma boucle for, dans ma classe, mis du commentaire. A cette endroit, j'aimerais faire ce qui est commenté (algo..). Sauf que le LCD est externe et est dépendant de mainwindows.cpp et mainwindows.h via l'ui.

Donc soit c'est faisable par une écoute de la classe (via un slot) qui toutes les secondes affiche un résultat partiel, soit ce n'est pas faisable et c'est virer de la classe pour être exécuter dans le main.

En espérant avoir pas trop fait un code trop mal.

Merci pour vos aides

[Caxton]

Bonjour,

Finalement, j'ai retirer mon système intermédiaire

Cela ne servais pas à grand chose dans le code à part l'alourdir inutilement pour faire une geekerie inutile au final.

Je vais donc poursuivre mon application

Jeter les dés fonctionne mais seulement localement. Dans la réalité, j'aimerais me servir de cette application avec d'autres en temps réel. Imaginon une partie de RPG (à l'ancienne, papier.... crayon... règles... musique d'ambiance...) si je suis joueur, je dois jeter les dés, je peux pas montrer aux autres, à distance le jet que j'ai fait. C'est là qu'il faudra donc mettre en place un système de client / serveur.

Plusieurs cas sont en prendre en ligne de compte.
A/ Cas de l'application orienté Master
1/ Si je suis MJ (Maître des jeux), j'ai certains jets de dés qui sont invisible. Donc pas besoin de montrer aux autres.
2/ Si je suis MJ et que je veux montrer aux autres mes jets.

B/ Cas de l'application orienté Joueur
1/ Tous mes jets doivent être visible de tous

La même application pouvant servir pour les deux cas, je pense faire un système d'onglet basculant. C'est à dire repeindre l'interface, selon que l'on choisit MJ ou Joueur.

Deuxièmement. N'est pas MJ qui veut ! Ce qui veut dire qu'un seul des participant peut avoir en même temps la zone MJ. Il faudra gérer le cas ou plusieurs MJ, dans chacun de leur jeu ai une interface identique. Là, je pense que la partie client / serveur, sera donc lancé à la main.

Exemple :
Onglet Connexion
Btn -> Créer serveur (si MJ)
Btn -> Se connecter à un serveur (si Joueur)

Mais pas les deux à la fois.

Bon, si je fais une deadline, je dirais que:
1/ Je refais une application neuve.
2/ Je crée le système de basculement de fenêtre. Via un bouton en haut ou par le menu déroulant. Pour les tests, ça sera par menu déroulant -> schecked
3/ Placer deux boutons ou deux textes pour tester le basculement.
4/ Implémenter la zone outils -> dès et outils -> Connexion
5/ Implémenter les paramètres.

Pour le moment, je vais me cantonner à l'interface si vous me permettez d'être réducteur ! Et de ne pas compter sur le reste de ma deadline tant que j'ai pas terminer avec celle-ci.

Comment je pourrait créer le basculement d'écran, sans avoir d'onglets par exemple ?

[Caxton]

Alors voilà !

J'ai pris mon courage à deux mains et j'ai fini par trouver une solution satisfaisante.

Je vais disposer dans la QToolBar, en haut, deux icônes. Une pour l'affichage Joueur, une pour l'affichage Master.

Par défaut, seule l'icône joueur est active. l'autre est bleue mais cliquable.
Si je clique sur la seconde, ça grise l'autre et ainsi de suite.

Comment donc faire cela dans le designer de Qt sachant que j'ai créer mes deux action dans l'éditeur d'action ?

Merci

[Caxton]

Bonjour,

Maintenant, au démarrage, j'ai besoin de proposer des choix. En effet, j'ai deux onglets dans mon application qui doivent pas être mise en marche en même temps. Du coup, je me dit:

1/ Au démarrage, l'application se lance.
2/ Immédiatement ensuite, une fenêtre MODALE (bloquante quoi), viens avec un choix du type:
2 bis -> Voulez-vous activer l'espace PJ ou l'espace MJ ?
3/ Si clic sur l'espace PJ, on viendra grisé et désactiver l'espace MJ, sinon, l'inverse.

A noter que je vais avoir besoin d'une variable particulière dans toute l'application. Elle permettra entre autre de changer la configuration de la connexion. Client en mode PJ, Serveur en mode MJ.

Donc, si je synthétise, il faut (démarrer l'apply et la bloquer. Faire ouvrir une popup et afficher les choix. Selon le choix fermer la popup, mettre a jour une variable locale, travailler sur les grisés ou non en fonction du choix.

Merci beaucoup pour votre aide.

Edit:

J'ai créer une nouvelle fenêtre que j'ai nommé dialogstart avec:
dialogstart.h

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
#ifndef DIALOGSTART_H
#define DIALOGSTART_H
 
#include <QDialog>
 
namespace Ui {
class DialogStart;
}
 
class DialogStart : public QDialog
{
    Q_OBJECT
 
public:
    explicit DialogStart(QWidget *parent = 0);
    ~DialogStart();
 
private:
    Ui::DialogStart *ui;
};
 
#endif // DIALOGSTART_H

dialogstart.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
 
#include "dialogstart.h"
#include "ui_dialogstart.h"
 
DialogStart::DialogStart(QWidget *parent) :
    QDialog(parent),
    ui(new Ui::DialogStart)
{
    ui->setupUi(this);
}
 
DialogStart::~DialogStart()
{
    delete ui;
}

Et bien sûr un ui pour générer tout ça.

Maintenant, j'aimerais faire en sorte que ça soit modale. On m'a parler de QSplashScreen, il semble adapté à une image. Ors, là, j'ai une boite de dialogue en quelque-sorte.

Du coup, j'essaie de faire cela:
main.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
#include "mainwindow.h"
#include <QApplication>
#include <QSplashScreen>
#include "dialogstart.h"
 
int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    MainWindow w;
 
    QSplashScreen dialogStart;
    //dialogStart -> ouvrir en modale dislogstart.cpp fenêtre de choix de début
 
 
    w.show();
 
    return a.exec();
}

Je ne suis pas certain de la validité du concept.

[Caxton]

Bon, voyant que j'avance à rien, je vais changer mon fusil d'épaule

Voila ce que j'avais conçu comme fenêtre au démarrage. A priori incompatible avec QSplashScreen. En plus QSplashScreen n'est là que pour attendre que le reste ce charge. Ce qui n'est pas mon cas !

Pièce jointe 123840

A partir de là, j'avais donc cherché à faire apparaître d'abord la popup avant de faire apparaître l'application en elle-même.

Ma question est donc, comment faire pour que , j'ouvre bien cette popup au départ ? Ensuite en fonction du choix, j'écoute les deux boutons qui font ceci :
Fermer la popup
Enregistrer le choix (je pense à un QSettings mais il faudra l'effacer à la fin pour qu'au prochain redémarrage on ai a nouveau le choix)
Faire apparaître la fenêtre et grisé tout sauf ce qui est choisi par le choix.

Merci.