Affichage de fenêtre définie dans une structure

Version imprimable

Bonjour à tous

Je vous remercie tous d'abord, vous qui prenez le temps de me lire :ccool:

Voici mon problème

J'ai une grosse Fenêtre

Code:

1
2
3
4
5
6
7
8
9
typedef struct{
GtkWidget* pWindow;
GtkWidget* pTable;
GtkWidget *pLabel[16];
GtkWidget *pImage[64];
GtkWidget *pBox[64];
GtkWidget *pButton[64];
gchar *sUtf8;
}WindowJeu;

Que j'initialise a partir d'un code ...

Code:

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
WindowJeu initialisationfenetre()
{
/* Déclaration Variable */
WindowJeu pWindow;
int i,j, compteurblanc,compteurnoir,compteurinitblanc,compteurinitnoire;
compteurblanc =0;
compteurnoir =32;
piece pieceBlanche[16];
compteurinitblanc = 0;
piece pieceNoire[16];
compteurinitnoire = 0;
 
gtk_window_set_title(GTK_WINDOW(pWindow.pWindow),"Jeu");
gtk_window_set_default_size(GTK_WINDOW(pWindow.pWindow),500,500);
g_signal_connect(G_OBJECT(pWindow.pWindow),"destroy",G_CALLBACK(gtk_main_quit),0);
gtk_container_add(GTK_CONTAINER(pWindow.pWindow), GTK_WIDGET(pWindow.pTable));
 
    for(i =0; i<16;i++)
    {
        pWindow.pLabel[i]=gtk_label_new(NULL);
    }
pWindow.pTable=gtk_table_new(9,9,FALSE);
    for(i=0; i<32;i++)
    {
        pWindow.pImage[i] = gtk_image_new_from_file("./blanc.png");
    }
    for(i=32; i<64;i++)
    {
        pWindow.pImage[i] = gtk_image_new_from_file("./noir.png");
    }
    for(i =0 ; i<64; i++)
    {
        pWindow.pButton[i] = gtk_button_new ();
        pWindow.pBox[i] = gtk_hbox_new (FALSE, 2);
        gtk_container_add (GTK_CONTAINER (pWindow.pButton[i]), pWindow.pBox[i]);
        gtk_box_pack_start (GTK_BOX (pWindow.pBox[i]), pWindow.pImage[i], TRUE, TRUE, 0);
    }
    pWindow.sUtf8 = g_locale_to_utf8("<span face=\"Sans\" size=\"16\"><u>1</u></span>",-1, NULL, NULL, NULL);
     gtk_label_set_markup(GTK_LABEL(pWindow.pLabel[0]), pWindow.sUtf8);
     g_free(pWindow.sUtf8);
pWindow.sUtf8 = g_locale_to_utf8("<span face=\"Sans\" size=\"16\"><u>2</u></span>",-1, NULL, NULL, NULL);
     gtk_label_set_markup(GTK_LABEL(pWindow.pLabel[1]), pWindow.sUtf8);
     g_free(pWindow.sUtf8);
pWindow.sUtf8 = g_locale_to_utf8("<span face=\"Sans\" size=\"16\"><u>3</u></span>",-1, NULL, NULL, NULL);
     gtk_label_set_markup(GTK_LABEL(pWindow.pLabel[2]), pWindow.sUtf8);
     g_free(pWindow.sUtf8);
pWindow.sUtf8 = g_locale_to_utf8("<span face=\"Sans\" size=\"16\"><u>4</u></span>",-1, NULL, NULL, NULL);
     gtk_label_set_markup(GTK_LABEL(pWindow.pLabel[3]), pWindow.sUtf8);
     g_free(pWindow.sUtf8);
pWindow.sUtf8 = g_locale_to_utf8("<span face=\"Sans\" size=\"16\"><u>5</u></span>",-1, NULL, NULL, NULL);
     gtk_label_set_markup(GTK_LABEL(pWindow.pLabel[4]), pWindow.sUtf8);
     g_free(pWindow.sUtf8);
pWindow.sUtf8 = g_locale_to_utf8("<span face=\"Sans\" size=\"16\"><u>6</u></span>",-1, NULL, NULL, NULL);
     gtk_label_set_markup(GTK_LABEL(pWindow.pLabel[5]), pWindow.sUtf8);
     g_free(pWindow.sUtf8);
pWindow.sUtf8 = g_locale_to_utf8("<span face=\"Sans\" size=\"16\"><u>7</u></span>",-1, NULL, NULL, NULL);
     gtk_label_set_markup(GTK_LABEL(pWindow.pLabel[6]), pWindow.sUtf8);
     g_free(pWindow.sUtf8);
pWindow.sUtf8 = g_locale_to_utf8("<span face=\"Sans\" size=\"16\"><u>8</u></span>",-1, NULL, NULL, NULL);
     gtk_label_set_markup(GTK_LABEL(pWindow.pLabel[7]), pWindow.sUtf8);
     g_free(pWindow.sUtf8);
pWindow.sUtf8 = g_locale_to_utf8("<span face=\"Sans\" size=\"16\"><u>8</u></span>",-1, NULL, NULL, NULL);
     gtk_label_set_markup(GTK_LABEL(pWindow.pLabel[7]), pWindow.sUtf8);
     g_free(pWindow.sUtf8);
pWindow.sUtf8 = g_locale_to_utf8("<span face=\"Sans\" size=\"16\"><u>A</u></span>",-1, NULL, NULL, NULL);
     gtk_label_set_markup(GTK_LABEL(pWindow.pLabel[8]), pWindow.sUtf8);
     g_free(pWindow.sUtf8);
pWindow.sUtf8 = g_locale_to_utf8("<span face=\"Sans\" size=\"16\"><u>B</u></span>",-1, NULL, NULL, NULL);
     gtk_label_set_markup(GTK_LABEL(pWindow.pLabel[9]), pWindow.sUtf8);
     g_free(pWindow.sUtf8);
pWindow.sUtf8 = g_locale_to_utf8("<span face=\"Sans\" size=\"16\"><u>C</u></span>",-1, NULL, NULL, NULL);
     gtk_label_set_markup(GTK_LABEL(pWindow.pLabel[10]), pWindow.sUtf8);
     g_free(pWindow.sUtf8);
pWindow.sUtf8 = g_locale_to_utf8("<span face=\"Sans\" size=\"16\"><u>D</u></span>",-1, NULL, NULL, NULL);
     gtk_label_set_markup(GTK_LABEL(pWindow.pLabel[11]), pWindow.sUtf8);
     g_free(pWindow.sUtf8);
pWindow.sUtf8 = g_locale_to_utf8("<span face=\"Sans\" size=\"16\"><u>E</u></span>",-1, NULL, NULL, NULL);
     gtk_label_set_markup(GTK_LABEL(pWindow.pLabel[12]), pWindow.sUtf8);
     g_free(pWindow.sUtf8);
pWindow.sUtf8 = g_locale_to_utf8("<span face=\"Sans\" size=\"16\"><u>F</u></span>",-1, NULL, NULL, NULL);
     gtk_label_set_markup(GTK_LABEL(pWindow.pLabel[13]), pWindow.sUtf8);
     g_free(pWindow.sUtf8);
pWindow.sUtf8 = g_locale_to_utf8("<span face=\"Sans\" size=\"16\"><u>G</u></span>",-1, NULL, NULL, NULL);
     gtk_label_set_markup(GTK_LABEL(pWindow.pLabel[14]), pWindow.sUtf8);
     g_free(pWindow.sUtf8);
pWindow.sUtf8 = g_locale_to_utf8("<span face=\"Sans\" size=\"16\"><u>H</u></span>",-1, NULL, NULL, NULL);
     gtk_label_set_markup(GTK_LABEL(pWindow.pLabel[15]), pWindow.sUtf8);
     g_free(pWindow.sUtf8);
     for(i=0; i<8;i++)
        {
        gtk_table_attach(GTK_TABLE(pWindow.pTable), pWindow.pLabel[i],
                 0, 1, i, i+1,
                 GTK_EXPAND , GTK_EXPAND,
                 0, 0);
        }
    for(i=0; i<8;i++)
        {
            gtk_table_attach(GTK_TABLE(pWindow.pTable), pWindow.pLabel[i+8],
                 i+1, i+2, 8, 9,
                 GTK_EXPAND, GTK_EXPAND,
                 0, 0);
        }
        for(i=0; i<8;i++)
        {
            for(j=0; j<8;j++)
                {
                    if((j+i)%2==0)
                    {
 
 
                        gtk_table_attach_defaults(GTK_TABLE(pWindow.pTable), pWindow.pButton[compteurblanc],i+1, i+2, j, j+1);
                        compteurblanc ++;
                        printf("\n%d",compteurblanc);
                        if(j<2 && i<8)
                           {
                                gtk_image_set_from_file(GTK_IMAGE(pWindow.pImage[compteurblanc-1]), "./pionNb.png");
                                pieceNoire[compteurinitnoire].positionX = i;
                                pieceNoire[compteurinitnoire].positionY = j;
                                printf("Pièce Noire (%d : %d )\n",pieceNoire[compteurinitnoire].positionX,pieceNoire[compteurinitnoire].positionY);
                                compteurinitnoire++;
                           }
                        if(((j>=6) && (j<=8) &&(i<8)))
                        {
                            gtk_image_set_from_file(GTK_IMAGE(pWindow.pImage[compteurblanc-1]), "./pionBb.png");
                            pieceBlanche[compteurinitblanc].positionX = i;
                            pieceBlanche[compteurinitblanc].positionY = j;
                            printf("Pièce blanche (%d : %d )\n",pieceBlanche[compteurinitblanc].positionX,pieceBlanche[compteurinitblanc].positionY);
                            compteurinitblanc++;
                        }
 
                    }
                    else
                    {
                        gtk_table_attach_defaults(GTK_TABLE(pWindow.pTable), pWindow.pButton[compteurnoir],i+1, i+2, j, j+1);
                        compteurnoir ++;
                         printf("\n%d",compteurnoir);
                         if(j<2 && i<8)
                           {
                                gtk_image_set_from_file(GTK_IMAGE(pWindow.pImage[compteurnoir-1]), "./pionNn.png");
                                pieceNoire[compteurinitnoire].positionX = i;
                                pieceNoire[compteurinitnoire].positionY = j;
                                printf("Pièce Noire (%d : %d )\n",pieceNoire[compteurinitnoire].positionX,pieceNoire[compteurinitnoire].positionY);
                                compteurinitnoire++;
                           }
                        if(((j>=6) && (j<=8) &&(i<8)))
                        {
                            gtk_image_set_from_file(GTK_IMAGE(pWindow.pImage[compteurnoir-1]), "./pionBn.png");
                            pieceBlanche[compteurinitblanc].positionX = i;
                            pieceBlanche[compteurinitblanc].positionY = j;
                            printf("Pièce blanche (%d : %d )\n",pieceBlanche[compteurinitblanc].positionX,pieceBlanche[compteurinitblanc].positionY);
                            compteurinitblanc++;
                        }
                    }
                }
                printf("\nDone\n");
        }
}

Code:

1
2
3
4
5
6
7
8
9
10
11
void fenetrejeu()
{

WindowJeu Window;
Window = initialisationfenetre() ;


gtk_widget_show_all(Window.pWindow);
gtk_main();

}

Voici mes questions :
1°) mon code est assez long pour la fenetre, existe un moyen de le réduire ?
2°) lors que j'essai d'afficher la fenêtre avec la commande gtk gtk_widget_show_all(Window.pWindow);, le programme bug, et il m'indique que le programme a cessé de fonctionné.
3°) Enfin ( cette question n'est pas la prioritaire ), il existe-t-il un moyen, lorsqu'on, clique sur un des bouton de faire bougé l'image qui lui est associé, je pense notamment au image pour les pions.

Je remercie encore une fois tous ceux qui auront le courage de me lire ...

Cordialement

11/01/2013, 11h35
liberforce

Qu'est-ce que tu fais comme jeu, un jeu de dames, d'échecs, un othello ?
11/01/2013, 11h54
kevingiroux

Bonjour

Il s'agit d'un jeu d’échec simplifier ... ( avec uniquement des pions 16 par couleurs )
11/01/2013, 14h18
pvincent
Bonjour,
Il est difficile de t'aider efficacement sans avoir un programme autonome.
En ajoutant une structure "piece", puis en transformant
Code:

1 2 // WindowJeu initialisationfenetre() void initialisationfenetre()
car elle ne retourne aucune valeur, et
Code:

1 2 //void fenetrejeu() int main(int argc,char **argv),
puis en rajoutant

Code:

gtk_init(&argc,&argv);

on trouve que le widget pWindow.pWindow n'est pas défini...

Je pense qu'au lieu de répéter 16 fois la même séquence tu as intérêt à définir un tableau de caractères (nom[16] par exemple) 1 à 9 et A à H et de faire une boucle avec un sprintf (..., nom[i]);
dans un buffer utilisé comme argument de g_locale_to_utf8().

Je me demande pourquoi tu déclare en tableaux pieceBlanche et pieceNoire sachant que ce sont des variable locales qui ne peuvent être utilisées qu'a l'intérieur de la fonction.
Je me permet de rajouter une règle de base: compiler le plus souvent possible, dès que l'on écrit quelque chose: les messages du compilateur sont une aide inestimable et le débutant à toujours tendance à écrire trop de lignes avant d'essayer de compiler.
11/01/2013, 16h34
kevingiroux

1 pièce(s) jointe(s)
Bonjour pvincent

Merci pour ton message, cependant quelque précision :

Je peux fournir le code en entier.

Ma fenêtre comporte pas mal de widget, et par la fonction

initialisationfenetre() je souhaiterai la crée en faite.

Et puis la retourné afin de la de l'afficher dans fenetrejeu()

Ce que je n'ai pas dit, c'est que j'ai d'autre fenêtre et que celle la n'est qu'une fenêtre parmi les autres que j'appelle en cliquant sur un bouton.

Le problème c'est comment je dois faire pour que dans la fonction fenetrejeu() lors que j'utilise gtk_widget_show_all, cela m'affiche la fenetre que j'ai initialisé dans la fonction initialisation fenetre et qui est une fenetre du type.
Code:

1 2 3 4 5 6 7 8 9 typedef struct{ GtkWidget* pWindow; GtkWidget* pTable; GtkWidget *pLabel[16]; GtkWidget *pImage[64]; GtkWidget *pBox[64]; GtkWidget *pButton[64]; gchar *sUtf8; }WindowJeu;
Cordialement
11/01/2013, 18h01
pvincent

Après un premier essai, en utilisant un debogueur (nemiver ou ddd), on voit que ça plante sur la ligne 20 tout simplement parce que pWindow.pWindow n'est pas définie.
En effet pWindow (la structure) est déclarée localement dans la fonction initialisationfenetre() sans que ses membres ne soit définis dans celle-ci.
Si tu veux te servir de cette fenêtre ailleurs que dans cette fonction, il faudra prévoir de passer la structure en argument dans la fonction.
Au passage, ce n'est pas terrible de donner le même nom à une structure et à un de ses membres: il vaut mieux être plus expressif.
11/01/2013, 18h35
kevingiroux

Bonjour Pvincent

Je ne comprend pas ce que tu veux dire ...

tu veux que je fasse

initialisationfenetre(Window)

au lieu de cela ?

Window = initialisationfenetre() ;

Je viens de remarqué que j'avais oublier le return à la fin de la fonction, et lorsque j'ai rajouté, le problème qui faisait complément planté le programme a cesser

Cependant la console me dit

Gtk-Critical **:gtk_widget_show_all: assertion 'GTK_IS WIDGET <widget>' failed.

Voila l'erreur .. maintenant.

Pour ma part le compilateur, ne me dit pas que pWindow.pWindow pose problème, il compile normelement jusqu'a l 'exécution et lorsqu"il affiche la console ,il y a un probleme ...
11/01/2013, 20h04
pvincent

On a parfaitement le droit de donner le même nom à une structure et à un de ses membres, donc le compilateur ne signale rien: c'est une question de style.

Quand je propose d'être plus expressif, cela veut dire que "pWindow" pour nommer une structure ne me semble pas très opportun, moi je l'aurai appelée tout simplement jeu, puisque cela semble être la structure principale.

Ensuite quand tu déclare "WindowJeu pWindow"; les differents membres ne sont pas initialisés et par exemple le pointeur défini par "GtkWidget* pWindow" prend une valeur au hasard. Il faut ensuite créer le widget, par exemple avec gtk_window_new().
Remarque que pour dessiner un damier, il vaut peut-être mieux utiliser un autre GtlWidget.

Une variable locale (ici la structure pWindow) cesse d'exister quand tu sort de la fonction dans laquelle elle est créée, donc si tu compte accéder à cette fenêtre en dehors de la fonction initialisationfenetre(), il faut soit passer un pointeur sur cette structure en argument de la fonction, la structure étant déclarée par exemple dans main(), soit en faire une variable globale. Si ces notions te semble compliquées, consulte un cours de C.
11/01/2013, 20h07
kevingiroux

Merci

pour les explications

Je vais tenter de résoudre le problème

Si jamais j'ai d'autre problème je viendrai completer mon post

Citation:

Envoyé par kevingiroux

Je viens de remarqué que j'avais oublier le return à la fin de la fonction, et lorsque j'ai rajouté, le problème qui faisait complément planté le programme a cesser

Pour éviter ce genre d'erreur grossière, je te conseille d'activer les warnings du compilateur en compilant avec l'option -Wall.

Ensuite, comme pvincent, je te conseille de relire ton cours de C sur le passage par adresse et par valeur. Tu peux donc faire un return de ta structure locale, mais ce n'est généralement pas une très bonne idée. Déjà parce qu'il faut en connaître les implications (tu peux renvoyer la valeur d'une variable locale, mais si tu renvoies son adresse, tu cours à la catastrophe, car elle n'existe pas en dehors du contexte local), mais aussi parce qu'en termes de performance c'est souvent pourri. Ici si tu passes par valeur tu copies tous les champs de ta structure (soit 844 octets sur une architecture 32 bits), au lieu de copier 4 octets si tu passais par adresse.

Ensuite, j'ai du mal à voir pourquoi tu crées 64 GtkHBox, car tu peux mettre directement ton GtkImage dans ton bouton il me semble.

Quant à tes appels de type:
Code:

1 2 3 pWindow.sUtf8 = g_locale_to_utf8("F",-1, NULL, NULL, NULL); gtk_label_set_markup(GTK_LABEL(pWindow.pLabel[13]), pWindow.sUtf8); g_free(pWindow.sUtf8);
Tu peux remplacer ta chaîne par un buffer que tu rempliras avec g_snprintf, afin de générer la partie qui change entre chaque appel. Je ne suis pas sûr non plus que l'appel à g_locale_to_utf8 soit pertinent, sachant que tu utilises un chaîne en pur ASCII, qui est déjà un sous ensemble d'utf-8.

Pour ce qui est du nommage, évite d'appeler pWindow quelque chose qui n'est pas un pointeur. La notation hongroise c'est déjà un peu pourri en soi même, si c'est mal utilisé, c'est pire. Lire à ce sujet:
http://www.joelonsoftware.com/articles/Wrong.html

Autre remarque, au lieu de charger à chaque fois les 2 mêmes images avec gtk_image_new_from_file, crée 2 GdkPixBuf (les 2 buffers de pixels, ce sont les données de tes images) et charge tes images avec gdk_pixbuf_new_from_file, puis crée tes images avec gtk_image_new et affecte leur une des deux images avec gtk_image_new_from_pixbuf. Tu y auras en plus gagné de la détection d'erreur que gdk_pixbuf_new_from_file fournit, et tu ne chargeras tes images que 2 images au lieu de 64.

Pour la détection de tes erreurs, utilise un débogueur, ou au pire mets quelques appels à g_debug dans ton programme pour voir à quel endroit il plante et faire l'analyse toi même.

Juste par curiosité, c'est un projet pour une classe de quel niveau ?

Autre remarque, dans Fenetreinscription.c, tu écris:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 gchar* sUtf8; gchar* sUtf9; gchar* sUtf10; ... /* Label 1*/ sUtf8 = g_locale_to_utf8("Nom du Joueur \n",-1, NULL, NULL, NULL); gtk_label_set_markup(GTK_LABEL(pLabel[0]), sUtf8); g_free(sUtf8); /* Label 2*/ sUtf9 = g_locale_to_utf8("Prénom du joueur \n",-1, NULL, NULL, NULL); gtk_label_set_markup(GTK_LABEL(pLabel[1]), sUtf9); g_free(sUtf9); /* Label 3*/ sUtf10 = g_locale_to_utf8("Mot de passe \n",-1, NULL, NULL, NULL); gtk_label_set_markup(GTK_LABEL(pLabel[2]), sUtf10); g_free(sUtf10);
Déjà, utf8, ça correspond à quelque chose de précis, le codage de caractères utf8. Donc utf9 et utf10 n'ont aucun sens.

Ensuite, tu crées 2 variables que tu remplis, utilises, puis vides. Mais ce sont des variables de même type, que tu utilises pour un usage similaire, et tu pourrais juste en créer une seule et la réutiliser par la suite:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 gchar* sLabel; sLabel = g_locale_to_utf8("Nom du Joueur \n",-1, NULL, NULL, NULL); gtk_label_set_markup(GTK_LABEL(pLabel[0]), sLabel); g_free(sLabel); /* Label 2*/ sLabel = g_locale_to_utf8("Prénom du joueur \n",-1, NULL, NULL, NULL); gtk_label_set_markup(GTK_LABEL(pLabel[1]), sLabel); g_free(sLabel); /* Label 3*/ sLabel = g_locale_to_utf8("Mot de passe \n",-1, NULL, NULL, NULL); gtk_label_set_markup(GTK_LABEL(pLabel[2]), sLabel); g_free(sLabel);
Bon, c'est un exemple, dans ce cas précis, tout ça est à mon avis un peu inutile. Tu devrais pouvoir passer des appels à g_locale_to_utf8 en enregistrant ton fichier source en utf8 plutôt qu'en iso-8859-1. C'est à configurer dans les propriétés de ton éditeur de texte. Ça te ferait économiser pas mal de lignes de code et gagner en lisibilité.

Je te conseille aussi de découper ton code en objets, et d'utiliser la notation nomobjet_action. L'utilisation de l'anglais est pas mal aussi, parce qu'il n'y a pas d'accent dans cette lanque, du coup il y a moins d'hésitations sur le nommage des fonctions, et tu peux retrouver intuitivement le nom d'une fonction. Par exemple, dans jouer.h, on voit:
Code:

1 2 3 4 5 6 7 void saisieJoueur(joueur A); void ajoutJoueur(joueur A); void ouvertureJoueur(joueur joueur1); int verificationJoueur(joueur joueur1); void initialisationechequier(); void deplacement ();
On se rend compte que tu utilises des majuscules pour séparer les mots, mais pas toujours, du coup c'est plus difficile de se rappeler du nom exact d'une fonction. GTK est très bien fait à ce niveau: uniquement des minuscules dans les noms de fonctions, et underscore "_" comme caractère de séparation des mots. On se demande aussi ce que l'initialisation de l'échiquier vient faire dans la classe joueur. Idem pour le déplacement de pions. Bon, je ne te jette pas la pierre si tu n'as pas encore eu de cours en conception objet ;)

Autre gros soucis, dans initialisationechiquier, tu modifies une variable locale:

Code:

echequier echequier[8][8];

(au passage, on dit un échiquier, pas un échequier).
Du coup, dès que tu quitteras cette fonction, les données de la structure initialisée seront perdues, car la variable locale est détruite à la fin de la fonction.

Je pense que tu as essayé de tout coder d'un coup et que tu te lances à présent dans le débogage. C'est tentant comme approche, mais extrêmement chronophage, car tu ne vois les problèmes d'architecture qu'au dernier moment, là où c'est le plus difficile à modifier. Je te conseille donc d'essayer de bien découper tes objets, et de les valider un à un avant d'essayer de tout faire fonctionner ensemble.

21/01/2013, 20h09
kevingiroux

1 pièce(s) jointe(s)

Bonjour à tous
Merci pour vos réponses
Pour commencer LiberForce
C'est un projet pour 2e année de prépa ( sachant qu'on a 60 h de cours et Tp par ans :mouarf: )
Secondo :
J'ai résolu un des problèmes précédents, mais d'autre sont apparu, eh oui sinon cela ne serais pas drôle.
Je ne sais pas si je dois faire un autre sujet ou bien poster ici, donc je poste ici et si on demande je referai un sujet.
Suite une étude complète de mon CODE , j'ai remarqué que j'étais parti dans la mauvaise direction, j'ai dû " pratiquement" tout refaire ".
Mon problème vient sur l'action de jouer.
Lorsque le joueur clique sur un des boutons qui composent l'échiquier, l'image sur laquelle il a cliqué change et passe d'une image normale, a une image sélectionnée. Dans le même temps, je récupère les informations relatives, à la case, c'est-à-dire l’abscisse et l'ordonnée, ainsi que la couleur de la case.
Le problème, cela marche uniquement pour la première ligne de chaque pion, et arriver sur la 3e ligne le problème se posait, les pions ne voulaient plus avancer (il faisait de la résistance que j'ai matée :mouarf: )
Mon problème :
-Lors que j'arrive au niveau la ligne 3, le temps d'affichage des informations sont beaucoup plus longs, et je ne comprends pas pourquoi ...
Concernant le débuggeur que vous me conseillez d’utiliser, j’utilise Code Block,
Si je dois installer un autre débuggeur comment dois-je faire, pour l’installer et le configurer pour CodeBlocks.
Cordialement
PJ : mon nouveau code complet.

Pour commencer, compile avec les warnings activés, et corrige-les. Ce sont des sources d'erreurs potentielles.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
Scanning dependencies of target chess
[ 12%] Building C object CMakeFiles/chess.dir/echiquier.c.o
/home/luis/devel/test/echiquier/echiquier.c:91:5: warning: built-in function ‘y1’ declared as non-function [enabled by default]
[ 25%] Building C object CMakeFiles/chess.dir/Fenetreconnexion.c.o
[ 37%] Building C object CMakeFiles/chess.dir/Fenetreinscription.c.o
[ 50%] Building C object CMakeFiles/chess.dir/fenetrejeu.c.o
/home/luis/devel/test/echiquier/fenetrejeu.c: In function ‘fenetrejeu’:
/home/luis/devel/test/echiquier/fenetrejeu.c:216:7: warning: unused variable ‘j’ [-Wunused-variable]
[ 62%] Building C object CMakeFiles/chess.dir/fenetrelancement.c.o
[ 75%] Building C object CMakeFiles/chess.dir/fonction.c.o
/home/luis/devel/test/echiquier/fonction.c: In function ‘on_activate_entry’:
/home/luis/devel/test/echiquier/fonction.c:83:27: warning: variable ‘sText’ set but not used [-Wunused-but-set-variable]
/home/luis/devel/test/echiquier/fonction.c: In function ‘on_about_btn’:
/home/luis/devel/test/echiquier/fonction.c:131:10: warning: too many arguments for format [-Wformat-extra-args]
/home/luis/devel/test/echiquier/fonction.c: In function ‘transition_btn’:
/home/luis/devel/test/echiquier/fonction.c:232:6: warning: implicit declaration of function ‘lancement’ [-Wimplicit-function-declaration]
[ 87%] Building C object CMakeFiles/chess.dir/joueur.c.o
[100%] Building C object CMakeFiles/chess.dir/main.c.o

Ensuite, j'ai trouvé ton interface assez désharçonnante. J'ai utilisé le compte test/test pour jouer (le mot de passe est en clair dans ton fichier). Cela fait partie des choses demandées ? Une des choses que j'ai trouvé bizarre, c'est notamment qu'on me présente 3 champs texte à remplir pour juste le couple login/mot de passe... Pour le jeu en lui même, je regarderai plus tard.

22/01/2013, 13h57
liberforce

Ton problème vient du fait que ta fonction déplacement est appelée 1 fois au premier déplacement, 2 au deuxième, 3 au troisième, etc (cela se voit facilement avec tes traces).

En fait dans actualisation_des_bouton tu connectes le signal "clicked" des cases à la fonction "deplacement". Le soucis c'est que dans deplacement, tu appelles directement "actualisation_des_boutons", qui reconnecte une nouvelle fois les signaux. La callback associée vient se rajouter dans une liste des callbacks associées à un couple instance d'un objet/signal. Du coup, si tu connectes 10 fois la même callback au même signal, la callback est appelée 10 fois.

Malheureusement, tu es en train de faire du code spaghetti. Tu n'as pas dissocié ce qui devrait avoir une influence sur l'état du jeu (la position des pièces) de ce que tu affiches à l'utilisateur.

Bonjour

Encore merci de ta réponse rapide.

Hier j'ai eu une petite idée, je ne sais pas si celle-là est une bonne idée ou une mauvaise idée ...

J'ai créé une fonction qui va uniquement actualiser les boutons que j'ai utilisés ...

Je ne sais pas ce si cela est correct de faire comme cela...
Code:

1 2 3 4 5 6 7 8 9 10 11 12 void actualisation_des_boutons_apres_deplacement(int x,int y) { macase = malloc(sizeof(s_case)); if(macase == NULL) { exit(0); } macase->x = echiquier[x][y].y; macase->y = echiquier[x][y].x; macase->contenu= echiquier[x][y].contenu; g_signal_connect(G_OBJECT(echiquier_graphique[x][y].pButton), "clicked", G_CALLBACK(deplacement), (gpointer)macase); }
Et en paramètre je passe les informations x et y correspondant au bouton qui a changé d'information.

Cependant est-ce la chose à faire ? ou justement comme tu me l'avais dit précédemment, cela va associer au même bouton, plusieurs lancements de fonction.

Concernant le code spaghetti, comment évité d'avoir ce cas la ?
Comment je dois faire pour séparer l'aspect graphique, jeu ... ???

Si je sépare, les deux, mes pions seront n'importe ou sur l'échiquier non ?

Ensuite :

Code:

/home/luis/devel/test/echiquier/echiquier.c:91:5: warning: built-in function ‘y1’ declared as non-function [enabled by default]

Comment faire pour corriger cette erreur, ayant une autre variable identique x1 déclarer au même endroit, pourquoi y1 pose un problème et pas x1 ?

Pour continuer :
Comment " crypter les données dans le fichier Joueur.dat qui est créé ??
Les mots de passe ainsi que les pseudo ( nom et prénom) sont visible
(pour te répondre, le Nom & prénom était la lorsque que je commençais avec GTK, je voulais un peu sortir du tutoriel qui était sur le site et donc me compliquer les exercices, d'ou le nom, prénom , joueur.

Lors de la version finale, il n'y aura que pseudo et Mot de passe )

Comment empêcher la lecture ???

Citation:
Envoyé par kevingiroux
J'ai créé une fonction qui va uniquement actualiser les boutons que j'ai utilisés ...

Je ne sais pas ce si cela est correct de faire comme cela...
Code:

1 2 3 4 5 6 7 8 9 10 11 12 void actualisation_des_boutons_apres_deplacement(int x,int y) { macase = malloc(sizeof(s_case)); if(macase == NULL) { exit(0); } macase->x = echiquier[x][y].y; macase->y = echiquier[x][y].x; macase->contenu= echiquier[x][y].contenu; g_signal_connect(G_OBJECT(echiquier_graphique[x][y].pButton), "clicked", G_CALLBACK(deplacement), (gpointer)macase); }
Et en paramètre je passe les informations x et y correspondant au bouton qui a changé d'information.

Cependant est-ce la chose à faire ? ou justement comme tu me l'avais dit précédemment, cela va associer au même bouton, plusieurs lancements de fonction.
Il y a le même problème... Tu ne peux pas reconnecter tes signaux après chaque mise à jour, sinon tu augmente le nombre de fois où ta callback sera appelée.

Citation:

Envoyé par kevingiroux

Concernant le code spaghetti, comment évité d'avoir ce cas la ?
Comment je dois faire pour séparer l'aspect graphique, jeu ... ???

Si je sépare, les deux, mes pions seront n'importe ou sur l'échiquier non ?

Non, tes pions ne seront pas n'importe où, c'est le but... Pour bien faire, tu devrais séparer le moteur de jeu (lintelligence, la logique du jeu d'échecs) de la partie graphique, qui ne doit qu'être une surcouche qui fait appel au moteur de jeu.

En gros, ton moteur ne doit gérer aucun objet graphique, juste ton tableau représentant ton échiquier, tes pions, tes joueurs. Même la couleur du fond de la case on s'en fout, ça n'a aucune influence sur le jeu, et c'est à la partie graphique de gérer ces problématiques. Cette séparation entre le moteur et la partie graphique rend le développement beaucoup plus flexible. Tu peux vouloir par exemple décider de coder ton jeu en Qt aussi, et dans ce cas là tu n'as qu'à remplacer la partie GTK. Tu peux donc conserver le moteur, ce qui t'évite de tout réécrire.

Vérifie donc que la logique du jeu fonctionne avant de te concentrer sur la partie graphique. Par exemple, ton moteur de jeu devrait pouvoir te dire si un déplacement est possible ou non. Dans l'idéal, tu saurais aussi quelles cases ont été modifiées par un déplacement (et si une pièce serait prise ou non par exemple), mais tu peux juste demander au moteur de te redécrire entièrement l'état de l'échiquier.

De l'autre côté, ta partie graphique en GTK va se contenter de faire des appels au moteur, surtout pour demander si un déplacement est possible, l'effectuer, et connaître le nouvel état de certaines cases ou de tout l'échiquier. Cela va considérablement simplifier ton travail car cela permet de se concentrer sur un unique problème (logique du jeu et logique d'affichage sont séparés). Du coup, quand un problème survient, c'est plus facile aussi de savoir dans quel fichier regarder si ton code est bien découpé.

Citation:

Envoyé par kevingiroux

Ensuite :

Code:

/home/luis/devel/test/echiquier/echiquier.c:91:5: warning: built-in function ‘y1’ declared as non-function [enabled by default]

Comment faire pour corriger cette erreur, ayant une autre variable identique x1 déclarer au même endroit, pourquoi y1 pose un problème et pas x1 ?

J'ai eu un peu de mal... Le message est clair, y1 est une fonction, et tu déclares une variable du même nom. Je me suis donc dit que tu avais déclaré une fonction y1 quelque part, mais non. Au final, y1 est une fonction fournie par math.h, que tu inclus (sans raison d'ailleurs) dans ton fichier. On t'avertit donc qu'utiliser une variable portant ce nom peut créer une confusion. La solution est de virer tous les #include qui ne servent à rien dans ce fichier. Normalement, on n'inclut que ce dont on se sert, toi tu as plutôt la main lourde.

Citation:

Envoyé par kevingiroux

Comment " crypter les données dans le fichier Joueur.dat qui est créé ??
Les mots de passe ainsi que les pseudo ( nom et prénom) sont visible
(pour te répondre, le Nom & prénom était la lorsque que je commençais avec GTK, je voulais un peu sortir du tutoriel qui était sur le site et donc me compliquer les exercices, d'ou le nom, prénom , joueur.

Lors de la version finale, il n'y aura que pseudo et Mot de passe )

Comment empêcher la lecture ???

Suis pas très fort en chiffrement, et pas forcément le temps de rentrer dans le sujet... Je ne suis d'ailleurs pas sûr que cela fasse partie de ce qu'on te demande. Concentre tes efforts sur la partie importante du sujet.

24/01/2013, 17h15
kevingiroux

Je vais donc séparer les information relative au jeu et après m'occuper de l'aspect comme tu la conseiller

Ce que tu me conseil c'est de faire une partie console et une partie graphique,
c'est a dire que je modifie le fichier echiquier.c pour qu'il n'y ai plus que des instruction console ?

Cordialement
24/01/2013, 17h54
liberforce
Ah, si pour le chiffrement, je viens de voir que la GLib propose GChecksum. La marche à suivre est donc:
- faire un hash type MD5 avec GChecksum sur le mot de passe fournit par l'utilisateur lors de son inscription.
- stocker le hash dans le fichier.
Quand l'utilisateur veut s'identifier:
- tu prends le mot de passe qu'il rentre
- tu refais le même type de hash
- tu compares ce hash à celui qui se trouve dans le ficher pour ce compte là
Le maître mot en sécurité: ne jamais stocker le mot de passe en clair.

Prenons un exemple concret: ta fonction modifier_contenu. Cette fonction manipule l'échiquier graphique. Le soucis, c'est que tu l'appelles à partir de ton échiquier non-graphique (qui fait partie de ton moteur). Tu enfreins donc une règle fondamentale de la conception qui est que les couches basses n'appellent jamais directement les couches plus hautes (l'exception à la règle étant le principe des callbacks, où tu indiques la couche inférieure la fonction à rappeler dans ta couche à toi).

Voici comment doivent se faire tes appels:
Code:

1 2 3 4 5 6 7 8 9 10 11 +---------------------+ | Application | | Graphique | +----+-----------+----+ | | +----v----+ +----v----+ | | | | | GTK | | Moteur | | | | | +---------+ +---------+
Prends l'exemple de GTK. Si tu as une fonction à exécuter, tu vas dire à GTK son nom, l'enregistrer comme callback, et lui l'appellera. C'est la bonne méthode.

La mauvaise méthode, c'est quand en plus, les couches basses appellent directement (c'est à dire, sans passer par une callback) les couches plus hautes. Il ne faut jamais faire cela ! Sinon ça devient du code spaghetti, avec des appels dans tous les sens et au bout d'un moment, tu ne sais plus comment une fonction donnée a été appelée... Tu risques aussi de te retrouver avec une récursion infinies avec B qui appelle A et A qui appelle B. Tu ne le verras pas forcément, car il y a peut être des fonctions intermédiaires qui rendront cela moins évident. Ex: A → C → B et B → D → A.

Pour revenir à ton cas concret, modifier_contenu ne devrait même pas exister. Le moteur n'a pas à agir sur la couche graphique. C'est à la couche graphique d'interroger le jeu pour connaître son état, et le traduire en éléments graphiques.

Petite remarque au passage: à ta place, j'implémenterais différemment même le type des cases. En effet, le moteur se fout de savoir si une case est blanche ou noire. Ce qu'il veut savoir c'est:
- si elle est vide ou occupée par une pièce quelconque (un pion dans ton cas, mais pour un vrai jeu d'échec, tu aurais les autres types de pièces)
- la couleur de la pièce (blanc ou noir)

Savoir si une case est blanche ou noire, c'est le boulot de la partie graphique, car cette notion n'a de sens que pour l'interface graphique. Elle interroge le moteur pour savoir si un déplacement est autorisé (ou pas), et met à jour l'interface en conséquence. Elle demande au moteur d'effectuer le déplacement. Elle connaît l'origine et la destination de ce déplacement, elle peut donc demander au moteur le contenu de ces cases après le déplacement, et l'afficher. Comme tu le vois, c'est la partie graphique qui interroge toujours le moteur, ou lui demande d'effectuer des actions, jamais l'inverse.

Pour t'aider dans la conception, regarde l'API (interface de programmation) des composants GTK. Les objets y sont clairement définis, et tu peux voir d'un coup d'oeil la liste des actions que tu peux effectuer dessus. Découpe bien tes fichiers de la même façon: un objet (échiquier, joueur, etc.) par couple de fichiers .h/.c. Dans les fichiers .c de ton moteur, retire les #include correspondant à tout ce qui n'est pas un objet faisant partie du moteur. Essaie de compiler: là où ça ne compile plus, c'est que tu appelles la partie graphique à partir du moteur. Tu dois donc modifier ces fonctions, ou les déplacer si elles appartiennent à un autre objet.