Troisième défi Qt : les résultats du jeu d'échecs

Image non disponible

Les défis Qt sont des petits exercices à faire soi-même ou en équipe sur un sujet précis. Le sujet de ce défi était le jeu d'échecs. Le défi étant terminé, nous vous présentons les résultats ainsi que le gagnant !

Retrouvez ce défi sur le forum.

Article lu   fois.

Les deux auteurs

Liens sociaux

Viadeo Twitter Facebook Share on Google+   

I. Présentation

L'équipe Qt vous souhaite la bienvenue sur la page du troisième défi Qt.

Les défis Qt sont des petits exercices à faire soi-même ou en équipe sur un sujet précis, à la manière des examens ou des exercices de livres. Ces codes à écrire sont étudiés de sorte que tous y trouvent leur compte : parfois de l'algorithmique, mais pas uniquement, car Qt ne fait pas que dans ce domaine spécifique. Il s'agit d'un framework complet : les défis essayent d'exploiter cette richesse. Ceci ne signifie pas qu'aucune réflexion n'est nécessaire : il faut connaître Qt, il ne s'agit pas d'écrire quelques lignes sans y réfléchir.

Retrouvez ce défi sur le forum.

Les membres du jury avaient à leur disposition une grille afin de les aider dans la cotation des programmes rendus. Elle leur laissait un certain degré de liberté, notamment dans la sévérité de certains éléments : chaque juré a fait selon ses critères personnels, ce qui peut donner des résultats complètement différents d'un juré à l'autre pour une même application. La voici pour rappel.

Certains critères étaient obligatoires : tous les points cités compteront dans la note finale. D'autres étaient optionnels : seul la meilleure cote des deux sera retenue. Les derniers, enfin, étaient supplémentaires : des bonus en cas de dépassement de nos demandes, ou des malus en cas de régression profonde (avertissements à la compilation, par exemple).

Vous trouverez ce tableau complété pour chaque participant et pour chaque juré ayant évalué le programme, avec ses commentaires. Les noms des jurés n'apparaîtront jamais à proximité de leurs commentaires, pour des raisons d'anonymat (personne ne saura qui a corrigé qui, qui a fait quels commentaires : personne ne pourra juger de la partialité de tel juge, cela évitera les MP excessifs si un juge a mis une cote trop basse aux yeux du participant, par exemple ; cependant, chaque juré a un numéro, qu'il gardera tout au long de la page, afin que chaque candidat puisse se comparer face à un seul juré pour tous les critères aux autres membres et voir ses forces et faiblesses). Les participants sont invités à regarder les commentaires afin de s'améliorer : il s'agit d'un regard externe sur la participation rendue, qui peut vous faire remarquer vos points faibles et vos points forts. Ils sont utiles à tous aussi : que faut-il faire, que faut-il éviter ? Les programmes sont présentés en fonction de l'ordre alphabétique des participants. Bonne consultation.

Critère Points à accumuler
(48 au total)
Fonctionnement minimal du programme Total : 20
Fonctionnement de base 8
Interface graphique 6
Fluidité 6
Qualité du code Total : 14
Qualité d'un point de vue du code 4
Qualité d'un point de vue Qt 4
Gestion des structures de données 3
Gestion de la mémoire 2
Documentation minimale 1
Fonctionnalités obligatoires Total : 14
Règles standard 10
Mode de jeu 1 contre 1 4
Bonus (critères facultatifs) Total : + 38
Documentation en suffisance 2
Module réseau pour jouer à distance 3
Utilisation d'une IA externe 3
Implémentation d'une IA 9
Mode 3D 6
Utilisation des capteurs accessibles sur le périphérique cible 5
Comptes utilisateur et gestion des scores en ligne 3
Animation de jeu 2
Surprenez-nous ! 5
Malus Total : -16
Utilisation d'un autre langage (sont autorisés tous les langages qui peuvent utiliser Qt directement [C++, Python, Java...] ainsi que tous les langages que Qt utilise [en ce compris ECMAScript/JavaScript, QML, (X)HTML, Lua via QtLua/LQt, etc.]) hors communication avec une IA. -4
Utilisation d'une autre bibliothèque non prévue pour Qt hors éventuelle IA (comme GNU chess). -4
Application peu robuste -2
Application semblant plantée -2
Erreurs à la compilation -2
Avertissements à la compilation (sauf si justification dans le README) -1
Fichiers inutiles dans l'archive -1

II. LittleWhite

Moyenne obtenue : 38,8125 / 48.

Les sources.

II-A. Juré 12

Critère Points à accumuler
(48 au total)
43,25 Bonne participation, lacunes non pas d'un point de vue du code mais plutôt de l'interface graphique. Probablement manque de temps.
Fonctionnement minimal du programme Total : 20 13  
Fonctionnement de base 8 7 Le fonctionnement de base est implementé, on peut jouer aux échecs avec une interface graphique contre un joueur humain ou un ordinateur. Un point en moins pour la non mise en place d'un timer et l'information du joueur en cours de jeu qui selon moi correspond au fonctionnement de base d'un jeu d'échecs.
Interface graphique 6 3 C'est très dommage qu'il n'y ai pas de validation à la volée des déplacement pour les joueurs. En un contre un, quand c'est par exemple aux blancs de jouer, il est possible de déplacer toutes les pièces noires n'importe comment sur le plateau, elle ne seront que replacé correctement qu'une fois qu'un coup blanc valide aura été joué. L'interface est très simpliste, lorsque deux joueurs jouent l'un contre l'autre, Il n'est pas toujours évident de savoir à qui est le tour si l'on quittes la pièce et reviens. Nénamoins le déplacement des pièces est très bien fait pour GNU Chess. Après avoir chargé un fichier incorrect, le jeu se réinitialise, on peut jouer comme une nouvelle partie mais jamais sauvegardé (bouton grisé). Utilisation d'image en SVG, ce qui permet un redimensionnement de la fenêtre sans perte de qualité, très bien.
Fluidité 6 3 L'interface graphique n'est pas toujous très fluide. Lorsque l'on fait des mouvements non permis, il y a parfois un certains temps avant que la pièce revienne à sa position initiale. Cela permet au joueur de redéplacer une autre piéce qui sera ajouté à la pile d'événement sans que l'interface graphique ne réponde sur le moment. Tout se résoud éventuellement mais la fluidité n'est pas au rendez-vous. Il arrive réguliérement que au lancement d'une partie les pièces ne s'affiche pas et qu'il y ai besoin de redimensionné la fenêtre pour commencer à joueur. Problème de rafraichissement rès probablement. De même, la pièce blanche se repositonne bien au centre de la case non pas au drop mais quand la pièce noir à fini de jouer (un temps de retard).
Qualité du code Total : 14 13  
Qualité d'un point de vue du code 4 3,5 Code C++ d'une bonne qualité, utilisation avancé des templates (bien que discutable pour un jeu de cet ampleur, mais on comprend que l'utilisation a été plus pour l'exercice) ainsi que de l'héritage pour rendre le jeu de plateau générique. Utilisation correcte des asserts, très bonne pratique de développement. Utilisation de static const int à la place de enum, je ne comprends pas pourquoi ? Par exemple pour le type de pièces, une enum me parait beaucoup mieux adaptée. Respect d'une charte de codage consistante de ce que j'ai vu. La partie commenté dans main.cpp aurait du être supprimé si elle ne compile pas. Utilisation de classe utilitaires avec fonction statique, bonne méthode et pratique pour les tests unitaires. Implémentation d'un systéme de listener/notifier. Quelques tests unitaires, très peu mais fonctionnels et très bonne pratique.
Qualité d'un point de vue Qt 4 4 Utilisation correcte des fichiers UI. Utilisation des streams pour la sauvegarde, bonne méthode. Utilisation correct du framework graphics view bien que plusieurs problèmes de rafraichissement. Utilisation des QActions, bonne pratique. Utilisation des tests unitaire Qt correcte. Par contre, utilisation des classes std plus que Qt (string, vector, etc.), raison particulière ? Une fois Qt inclut, je trouve plus utile d'utiliser leur conteneurs. Utilisation correcte des mutex + sémaphores en Qt. Dans l'ensemble, aucun problème majeure detecté sur l'utilisation de Qt. Je trouve qu'il aurait été surement facile de faire une QUndoStack avec le systéme de movement mis en place, à creuser pour une prochaine version.
Gestion des structures de données 3 2,5 Gestion générique d'un plateau à n dimensions avec implémentation d'un plateau à 2D dans notre cas + gestion générique des régles pour pouvoir jouer aux échecs ou aux dames. Dames non fonctionnel au moment du rendu. Gestion des mouvements avec une classe Move, bonne méthode.
Gestion de la mémoire 2 2 Pas vu d'erreur majeur d'utilisation de la mémoire lors de ma lecture de code. L'utilisation des (void) pour les paramétres non utilisé est une pratique non obligatoire mais correct. D'ailleurs une macro Qt existe, quelque chose comme QT_UNUSED.
Documentation minimale 1 1 Documentation minimale atteinte.
Fonctionnalités obligatoires Total : 14 11  
Règles standard 10 7 Lorsqu'il y a échec et mat, le jeu ne s'arréte pas. Possibilité pour le Roi de se mettre lui-même en échec lors d'un de mes scénarios de jeu. Promotion des pièces marche impeccable avec une fenêtre de dialogue pour choisir la nouvelle pièce. Pris en passant non implementé (essai avec un exemple basique de deux pions avançant en même temps à coté de l'autre). Pat non testé car crash avant mise en place de la situation mais au vue du code, implementé (bien qu'un peu confus entre le pat et la régle des 50 coups dans le nom des variables).
Mode de jeu 1 contre 1 4 4 Le mode de jeu est implementé sans soucis majeur.
Bonus (critères facultatifs) Total : + 38 + 9,5  
Documentation en suffisance 2 2 Très bonne documentation dans les fichiers d'en-tête, en anglais utilisant la syntaxe Doxygen et généré dans l'archive. De plus, documentation présente dans les fichier de code source en cas de fonction longue et compliqué (e.g ChessRules.cpp).
Module réseau pour jouer à distance 3 0  
Utilisation d'une IA externe 3 3 Utilisation de GNUChess en lancant un processus via un fork et en faisant communiquer les deux. L'utilisation de GNU Chess fonctionne correctement et est optionnelle pour utiliser l'application.
Implémentation d'une IA 9 0  
Mode 3D 6 0  
Utilisation des capteurs accessibles sur le périphérique cible 5 0  
Comptes utilisateur et gestion des scores en ligne 3 0  
Animation de jeu 2 1 Le déplacement des pièces est bien fait pour GNU Chess. Ce n'est pas une animation à proprement parler mais l'effet est quand même présent.
Surprenez-nous ! 5 3,5 Le système de sauvegarde est un bon plus. Le fichier sauvegardé est bien fait car il ne contient qu'un minimum d'information (les déplacements). Gestion des erreurs en cas d'édition du fichier et écriture de movement invalide. Il y a cependant un problème majeure dans la sauvegarde, il est nécessaire que ce soit au blanc de jouer pour que la sauvegarde fonctionne correctement, il s'agit toujours de la paire de combinaison (blanc + noir) qui est sauvegardé par ligne. Pour voir l'erreur, faite jouer (Joueur vs Joueur) le blanc et au tour des noirs, sauegardé. Chargé le même fichier et vous verrez que le dernier mouvement blanc est perdu ! Certaines animation sont complétemen incorrect, par exemple le déplacement d'un pion ou du roi de 5 cases pour manger une pièce alors qu'iul s'agit en fait d'un mauvais coup et d'une remise en place de la position initiale. Bonus pour les 2 régles de fin de partie implementé, à savoir la 3ème répitition d'une même position (draw) et la régle des 50 coups.
Malus Total : -16 -3,25  
Utilisation d'un autre langage (sont autorisés tous les langages qui peuvent utiliser Qt directement [C++, Python, Java...] ainsi que tous les langages que Qt utilise [en ce compris ECMAScript/JavaScript, QML, (X)HTML, Lua via QtLua/LQt, etc.]) hors communication avec une IA. -4 0 Rien vu de tel.
Utilisation d'une autre bibliothèque non prévue pour Qt hors éventuelle IA (comme GNU chess). -4 0 Utilisation de GNU Chess autorisée.
Application peu robuste -2 -2 Difficile de faire des scénarios de jeu très longs car l'application crashe (voir ligne du dessous) avant d'arriver à positionner les pièces.
Application semblant plantée -2 -1 J'ai eu plusieurs crashes RunTime Error, virtual pure function call. Cependant, pas d'autres crash connu. (Voir image ci-dessous.)
Erreurs à la compilation -2 0 Aucune erreur à la compilation (Qt 4.8.1, MSVC 2008).
Avertissements à la compilation (sauf si justification dans le README) -1 -0,25 Deux avertissements à la compilations non indiqués dans le ReadMe (Qt 4.8.1, MSVC 2008).
'PromotionDialog::getChoice' : les chemins de contrôle ne retournent pas tous une valeur.
'GameFactory::getNbControlersNeeded' : les chemins de contrôle ne retournent pas tous une valeur.
Même si un ASSERT est mis dans une condition et que l'utilisateur ne doit normalement à aucun moment entrer dans cet état, il est nécessaire de retourner une valeur (même inutile, comme zéro pour le nombre de joueurs). Dans tous les cas, en débogage, le programme s'arrêtera sur l'assert et le développeur devra la résoudre et considérer que, s'il l'ignore, le programme arrive dans un état indéfini et peut planter à tout moment.
Fichiers inutiles dans l'archive -1 0 Aucun fichier inutiles mais attention cependant à la création de fichier source vide. Un fichier d'entête suffit pour la classe Controler par exemple.
Image non disponible

II-B. Juré 13

Critère Points à accumuler
(48 au total)
41,5 Plutôt dommage en ce qui concerne l'interface graphique.
Fonctionnement minimal du programme Total : 20 14  
Fonctionnement de base 8 6 Pas de validation du mouvement des pièces sans GNUChess. En d'autres termes, inutilisable sans GNUChess – et même pas un avertissement pour prévenir !
Interface graphique 6 4 Sobre, mais suffisant.
Fluidité 6 4 En lançant l'IA contre elle-même, on n'est pas prévenu que quelque chose se fait – d'ailleurs, on peut déplacer soi-même les pièces pendant ce temps… Quand on tente de prendre une pièce, les deux coexistent sur la même case jusqu'à ce que l'autre joueur ait joué.
Qualité du code Total : 14 13  
Qualité d'un point de vue du code 4 3,5 Du code comme on aimerait en avoir plus souvent !
Qualité d'un point de vue Qt 4 3,5  
Gestion des structures de données 3 3  
Gestion de la mémoire 2 2 Pas de problème constanté.
Documentation minimale 1 1  
Fonctionnalités obligatoires Total : 14 10  
Règles standard 10 8  
Mode de jeu 1 contre 1 4 2 Inutilisable en l'état : on peut jouer n'importe quoi n'importe quand... À moins d'installer GNU Chess.
Bonus (critères facultatifs) Total : + 38 +7  
Documentation en suffisance 2 2 Avec utilisation de Doxygen !
Module réseau pour jouer à distance 3 0  
Utilisation d'une IA externe 3 2 Utilisation de GNU Chess. Je n'ai pas trouvé d'autre manière de faire fonctionner ce pont que de mettre le chemin vers l'exécutable en dur (Windows). Tout (ou presque) dépend de cette IA, même en partie entre humains.
Implémentation d'une IA 9    
Mode 3D 6    
Utilisation des capteurs accessibles sur le périphérique cible 5    
Comptes utilisateur et gestion des scores en ligne 3    
Animation de jeu 2    
Surprenez-nous ! 5 3 Un code vraiment prévu pour l'extensibilité ! Bon, un système de plug-ins pour les types de jeu m'aurait vraiment bluffé.
Malus Total : -16 -2,5  
Utilisation d'un autre langage (sont autorisés tous les langages qui peuvent utiliser Qt directement [C++, Python, Java...] ainsi que tous les langages que Qt utilise [en ce compris ECMAScript/JavaScript, QML, (X)HTML, Lua via QtLua/LQt, etc.]) hors communication avec une IA. -4    
Utilisation d'une autre bibliothèque non prévue pour Qt hors éventuelle IA (comme GNU chess). -4    
Application peu robuste -2 -2 Lors de déplacements erratiques des pièces, la vue se réinitialise ; parfois, un crash ou l'autre (en tentant de créer une deuxième partie, message d'erreur de la bibliothèque standard ; idem en fermant l'application).
Application semblant plantée -2    
Erreurs à la compilation -2    
Avertissements à la compilation (sauf si justification dans le README) -1 -0,5 Deux avertissements (VC10, pas GCC 4).
Fichiers inutiles dans l'archive -1    

II-C. Juré 14

Critère Points à accumuler
(48 au total)
37,5 La participation est vraiment très intéressante du point de vue du code. L'interface graphique aurait sans doute été plus poussée si le candidat avait disposé d'un peu plus de temps.
Fonctionnement minimal du programme Total : 20 12  
Fonctionnement de base 8 4 L'application permet de disputer des parties intéressantes en mode humain contre humain, humain contre GNU Chess ou GNU Chess contre GNU Chess avec une fonction de sauvegarde et de chargement permettant de reprendre une partie à un point précis. Toutefois, pas mal de problèmes relatifs à GNU Chess sont présents sous Linux, notamment le fait que seul soit disponible le mode « joueur contre joueur » et que GNUChess prenne la main sur ce type de partie.
Interface graphique 6 2 Une interface graphique assez classique en 2D avec possibilité de visualiser les possibilités de déplacements et les menaces exercées. Cependant, plusieurs éléments sont à reprendre, en particulier le fait que les pièces puissent être bougées, peu importe le camp – même si ce n'est pas forcément pris en compte par la partie core de l'application –, engendrant la possibilité de préparer des coups à l'avance et générant de nombreuses possibilités d'erreur de manipulation. De même, on constate des problèmes par rapport à la vue graphique : lors d'un mouvement d'une pièce à l'extérieur du plateau, des barres de défilement apparaissent, ce qui peut gêner l'utilisateur. Il aurait également été apprécié de trouver quelques indicateurs pour informer d'un échec ou bien du camp devant jouer le coup suivant.
Fluidité 6 6 La simplicité de l'interface et la bonne construction de la partie core de l'application fait qu'aucun problème relatif à la fluidité n'a été constaté.
Qualité du code Total : 14 13  
Qualité d'un point de vue du code 4 4 Le code est bien hiérarchisé, il permet d'intégrer aisément divers types de jeu de plateau (échecs, dames, etc.) par le biais de classes héritant des classes Board et Board2D et divers types de parties avec la classe template Game. Les règles sont implémentées par le biais de classes héritant des classes Rules et Rules2D. Un système d'historique est également géré dans des classes dédiées. Du threading est présent dans une classe GameLauncher. Bon travail.
Qualité d'un point de vue Qt 4 3 Le framework Qt est correctement exploité avec l'utilisation du mécanisme de signaux et de slots et l'héritage des classes GUI de QObject. Certains éléments de l'interface ont été créés avec Qt Designer pour alléger le code. On constate cependant un petit « rejet » des classes conteneur de Qt telles que QVector ou QMap au détriment de la STL avec, par exemple, std::vector ou std::map.
Gestion des structures de données 3 3 La structure des structures de données est idéale pour l'implémentation des règles et la mise sur pied d'une partie d'échecs. Elle est également adaptée à une implémentation d'autres jeux de plateau. Rien à dire.
Gestion de la mémoire 2 2 Aucune fuite de mémoire n'a été constatée.
Documentation minimale 1 1 Toutes les classes sont commentées, tout comme le sont les variables et méthodes membres.
Fonctionnalités obligatoires Total : 14 10  
Règles standard 10 6

Les règles permettent de jouer une partie sérieuse aboutissant à un mat. Plusieurs points restent à revoir :

  • la triple répétition n'est pas entièrement fonctionnelle : si un seul joueur (et non les deux) fait trois fois le même coup, un pat est détecté. Cela donne à chaque camp la possibilité de faire de l'anti-jeu en cas de mauvaise posture ;
  • le pat n'est pas correctement géré dans le cas où un camp ne pourrait plus se déplacer ;
  • prise en passant : le pion ayant effectuant la prise peut bel et bien effectuer le mouvement mais le pion qu'il doit prendre reste sur le plateau ;
  • gestion du roque : on a moyen de roquer sans la tour si on replace le roi à sa position d'origine et également de roquer à l'envers pour replacer le roi au centre ;
  • la règle des cinquante coups est implémentée mais non fonctionnelle.
Mode de jeu 1 contre 1 4 4 Trois modes de jeu sont disponibles : humain contre humain, humain contre GNU Chess (IA) ou GNU Chess (IA) contre GNU Chess (IA).
Bonus (critères facultatifs) Total : + 38 +4,5  
Documentation en suffisance 2 1 Voir « Documentation minimale ».
Module réseau pour jouer à distance 3 0 Fonctionnalité non implémentée.
Utilisation d'une IA externe 3 2 Utilisation de GNUChess pour deux modes de jeu. Il arrive toutefois que l'IA se bloque dans le cas où un mouvement interdit aurait été réalisé.
Implémentation d'une IA 9 0 Fonctionnalité non implémentée.
Mode 3D 6 0 Fonctionnalité non implémentée.
Utilisation des capteurs accessibles sur le périphérique cible 5 0 Fonctionnalité non implémentée.
Comptes utilisateur et gestion des scores en ligne 3 0 Fonctionnalité non implémentée.
Animation de jeu 2 0,5 Il arrive de manière assez aléatoire – du moins sous Linux – que des animations de déplacement se produisent.
Surprenez-nous ! 5 1 Le fait que le code puisse implémenter tous les types de jeux de plateau est vraiment très intéressant. Une ébauche de jeu de dames est en place dans le code.
Malus Total : -16 -2  
Utilisation d'un autre langage (sont autorisés tous les langages qui peuvent utiliser Qt directement [C++, Python, Java...] ainsi que tous les langages que Qt utilise [en ce compris ECMAScript/JavaScript, QML, (X)HTML, Lua via QtLua/LQt, etc.]) hors communication avec une IA. -4 0 La règle est respectée.
Utilisation d'une autre bibliothèque non prévue pour Qt hors éventuelle IA (comme GNU chess). -4 0 La règle est respectée.
Application peu robuste -2 -1 Un crash sous Linux lorsque l'application n'arrive pas à communiquer avec GNU Chess. Quelques comportements instables liés au fait que l'interface graphique ne bloque pas les déplacements non autorisés.
Application semblant plantée -2 0 Aucun problème de ce type détecté.
Erreurs à la compilation -2 0 La règle est respectée.
Avertissements à la compilation (sauf si justification dans le README) -1 -1 Deux avertissements de valeurs de retour non vérifiés des appels système read et write dans GNUChessControler.cpp pour la version Linux. Un autre relatif à un return manquant dans DameBoard::getDimensionLength().
Fichiers inutiles dans l'archive -1 0 La règle est respectée.

II-D. Juré 15

Critère Points à accumuler
(48 au total)
33  
Fonctionnement minimal du programme Total : 20 10  
Fonctionnement de base 8 4 Il n'y a pas de validation directe du mouvement des pièces.
Interface graphique 6 4 Sobre et suffisante.
Fluidité 6 2 L'application est fluide quand on bouge une pièce. Si un mouvement faux est effectué, l'application se bloque.
Qualité du code Total : 14 13  
Qualité d'un point de vue du code 4 4 Code propre et bon découpage.
Qualité d'un point de vue Qt 4 3 L'utilisation est correcte.
Gestion des structures de données 3 3  
Gestion de la mémoire 2 2  
Documentation minimale 1 1  
Fonctionnalités obligatoires Total : 14 5  
Règles standard 10 5 La dame n'est pas sur sa couleur au début.
Mode de jeu 1 contre 1 4 0 Il n'y a aucun contrôle des mouvements
Bonus (critères facultatifs) Total : + 38 +7  
Documentation en suffisance 2 2 Documentation Doxygen.
Module réseau pour jouer à distance 3 0  
Utilisation d'une IA externe 3 3 Un gros effort pour l'utilisation de GNU Chess.
Implémentation d'une IA 9 0  
Mode 3D 6 0  
Utilisation des capteurs accessibles sur le périphérique cible 5 0  
Comptes utilisateur et gestion des scores en ligne 3 0  
Animation de jeu 2 0  
Surprenez-nous ! 5 2  
Malus Total : -16    
Utilisation d'un autre langage (sont autorisés tous les langages qui peuvent utiliser Qt directement [C++, Python, Java...] ainsi que tous les langages que Qt utilise [en ce compris ECMAScript/JavaScript, QML, (X)HTML, Lua via QtLua/LQt, etc.]) hors communication avec une IA. -4 0  
Utilisation d'une autre bibliothèque non prévue pour Qt hors éventuelle IA (comme GNU chess). -4 0  
Application peu robuste -2 -2 L'application plante assez rapidement après un déplacement faux.
Application semblant plantée -2 0  
Erreurs à la compilation -2 0  
Avertissements à la compilation (sauf si justification dans le README) -1 0  
Fichiers inutiles dans l'archive -1 0  

II-E. Moyenne

Critère Points à accumuler
(48 au total)
38,8125
Fonctionnement minimal du programme Total : 20 12,25
Fonctionnement de base 8 5,25
Interface graphique 6 3,25
Fluidité 6 3,75
Qualité du code Total : 14 13
Qualité d'un point de vue du code 4 3,75
Qualité d'un point de vue Qt 4 3,375
Gestion des structures de données 3 2,875
Gestion de la mémoire 2 2
Documentation minimale 1 1
Fonctionnalités obligatoires Total : 14 9
Règles standard 10 6,5
Mode de jeu 1 contre 1 4 2,5
Bonus (critères facultatifs) Total : + 38 + 7
Documentation en suffisance 2 1,75
Module réseau pour jouer à distance 3 0
Utilisation d'une IA externe 3 2,5
Implémentation d'une IA 9 0
Mode 3D 6 0
Utilisation des capteurs accessibles sur le périphérique cible 5 0
Comptes utilisateur et gestion des scores en ligne 3 0
Animation de jeu 2 0,375
Surprenez-nous ! 5 2,375
Malus Total : -16 -2,4375
Utilisation d'un autre langage (sont autorisés tous les langages qui peuvent utiliser Qt directement [C++, Python, Java...] ainsi que tous les langages que Qt utilise [en ce compris ECMAScript/JavaScript, QML, (X)HTML, Lua via QtLua/LQt, etc.]) hors communication avec une IA. -4 0
Utilisation d'une autre bibliothèque non prévue pour Qt hors éventuelle IA (comme GNU chess). -4 0
Application peu robuste -2 -1,75
Application semblant plantée -2 -0,25
Erreurs à la compilation -2 0
Avertissements à la compilation (sauf si justification dans le README) -1 -0,4375
Fichiers inutiles dans l'archive -1 0

III. ness522

Moyenne obtenue : 51 / 48.

Les sources.

III-A. Juré 13

Critère Points à accumuler
(48 au total)
49 Une application poussée, très intéressante à tout point de vue. (Pour la promotion des pions, on aurait préféré qu'un double-clic suffise pour choisir la pièce.) Le plus gros manque : l'intégration d'une intelligence artificielle. L'impression générale est que l'application n'a pas été bâclée, mais qu'un petit tour de fignolages de gauche, de droite aurait été le bienvenu.
Fonctionnement minimal du programme Total : 20 19  
Fonctionnement de base 8 8 Le logiciel proposé est très complet, facile à prendre en main, agréable à utiliser. On pourrait l'utiliser pour des parties sérieuses.
Interface graphique 6 5 Interface de très bonne facture… et en 3D (on aurait pu demander un peu de lissage, histoire d'avoir toute la scène en escaliers).
Fluidité 6 6 Aucun problème de ce côté, magré la 3D.
Qualité du code Total : 14 10  
Qualité d'un point de vue du code 4 2 Seul gros défaut : un God Object dans ChessEngine, qui fait tout et plus encore (implémentation des règles comme méthodes, alors que ça aurait été mieux mis dans des classes séparées, une par type de pièce, comme dans la partie QML.
Qualité d'un point de vue Qt 4 3 La manière de définir les tailles de police pour les messages en QML n'est pas idéale (problèmes de portage sur d'autres plateformes et types d'écran), bien que seul le desktop soit visé.
Gestion des structures de données 3 3  
Gestion de la mémoire 2 1 Utilisation du Loader QML pas idéale, on recharge trop souvent tout un composant sans détruire le précédent (à chaque nouvelle partie).
Documentation minimale 1 1  
Fonctionnalités obligatoires Total : 14 13  
Règles standard 10 9 Quelques règles non implémentées, la majorité l'est.
Mode de jeu 1 contre 1 4 4  
Bonus (critères facultatifs) Total : + 38 +7  
Documentation en suffisance 2 0 Documentation minimale, oui, mais pas plus.
Module réseau pour jouer à distance 3 0  
Utilisation d'une IA externe 3 0  
Implémentation d'une IA 9 0  
Mode 3D 6 5 Mode 3D présent, bien que la qualité de rendu ne soit pas exceptionnelle (crénelage très présent).
Utilisation des capteurs accessibles sur le périphérique cible 5 0  
Comptes utilisateur et gestion des scores en ligne 3 0  
Animation de jeu 2 2 Animations fort présentes, rendant le jeu très agréable (comme le déplacement des pièces).
Surprenez-nous ! 5 0  
Malus Total : -16 0  
Utilisation d'un autre langage (sont autorisés tous les langages qui peuvent utiliser Qt directement [C++, Python, Java...] ainsi que tous les langages que Qt utilise [en ce compris ECMAScript/JavaScript, QML, (X)HTML, Lua via QtLua/LQt, etc.]) hors communication avec une IA. -4 0  
Utilisation d'une autre bibliothèque non prévue pour Qt hors éventuelle IA (comme GNU chess). -4 0  
Application peu robuste -2 0  
Application semblant plantée -2 0  
Erreurs à la compilation -2 0  
Avertissements à la compilation (sauf si justification dans le README) -1 0  
Fichiers inutiles dans l'archive -1 0  

III-B. Juré 14

Critère Points à accumuler
(48 au total)
49,5 Participation très intéressante du point de vue de l'interface graphique et du QML. Pourra-t-on voir ultérieurement une IA ?
Fonctionnement minimal du programme Total : 20 17  
Fonctionnement de base 8 7 Le logiciel est assez complet, on a la possibilité d'effectuer une partie sérieuse humain contre humain, du fait de la bonne implémentation des règles des échecs ainsi que de l'interface graphique agréable et intuitive en 3D.
Interface graphique 6 4 L'interface graphique présente une scène 3D représentant l'échiquier bordé d'un menu permettant de paramétrer l'orientation du plateau, de désactiver l'affichage des menaces ou encore de lancer une nouvelle partie. Des animations diverses et variées rendent l'application agréable à utiliser. Bon travail. Un léger souci graphique provenant d'OpenGL lorsqu'un indicateur de déplacement est situé à la même position qu'un indicateur de menace. D'autres problèmes seront abordés dans la partie Qualité d'un point de vue Qt avec une proposition de correction.
Fluidité 6 6 L'application est très fluide. Malgré la présence d'animations 3D, aucun lag n'a été constaté.
Qualité du code Total : 14 11  
Qualité d'un point de vue du code 4 3

Par rapport à la syntaxe elle-même du code, des coding rules sont respectées et le code est aéré comme il se doit. De ce fait, il n'est pas difficile de lire et de comprendre le code. Néanmoins, il serait judicieux de faire bien attention à ne pas oublier de placer les mentions « const » sur les paramètres et variables locales non modifiées.

Du point du vue C++, une classe ChessEngine est utilisée pour la gestion core de la totalité de la partie. Pour la réalisation de l'algorithme principal de l'application, il aurait pu être intéressant de faire quelques petites modifications. Tout d'abord, il aurait été possible de sous-classer Piece afin de reproduire un schéma similaire à celui utilisé dans la partie QML (des classes Pawn, King, etc. hériteraient de Piece). De plus, on peut ajouter que cette architecture permettrait à chaque type de pièce de gérer les comportements propres à eux-mêmes. Autrement dit, cela aurait permis à ChessEngine de se libérer de fonctions telles que les fonctions de déplacement des pièces selon leur type, de la promotion des pions, etc.

Mis à part cela, l'approche Model/View avec une partie core en C++ et une partie graphique en QML/JS est tout à fait correcte.

Qualité d'un point de vue Qt 4 3,5

Du côté de QML, deux détails. Le premier : on remarque sous Linux au lancement que les cases de l'échiquier sont trop grosses, tout comme les indicateurs de déplacement et de menace, ce qui crée des problèmes à voir sur quelle case de l'échiquier est chaque pièce. Ce problème provient de la valeur de BoardCellSpacing de DrawingConstants.js. Une proposition de correction :

 
Sélectionnez
--- DrawingConstants_old.js	2012-07-28 21:03:03.265542825 +0200
+++ DrawingConstants_new.js	2012-07-28 21:03:02.645529458 +0200
@@ -4,15 +4,15 @@
 var BoardHeight = 8
 var BoardCenterOffset_X = -BoardWidth / 2.0
 var BoardCenterOffset_Z = BoardWidth / 2.0
-var BoardCellSpacing = BoardWidth / 8.0
+var BoardCellSpacing = BoardWidth / 16.0
 var BoardTopSurfaceOffset = BoardHeight / 2.0
 var MovesDuration = 400

 function cellCenter_X(column) {
-    return BoardCenterOffset_X + BoardCellSpacing * (column + 0.5)
+    return BoardCenterOffset_X + BoardCellSpacing * 2 * (column + 0.5)
 }

 function cellCenter_Z(row) {
-    return BoardCenterOffset_Z - BoardCellSpacing * (row + 0.5)
+    return BoardCenterOffset_Z - BoardCellSpacing * 2 * (row + 0.5)
 }

Une capture d'écran du rendu :

Image non disponible

Le second détail touchant la partie QML : les messages « Échec aux blancs », « Échec et mat », etc. sont coupés et de taille bien trop grande selon le système. Il s'agit d'un problème lié aux polices ; il est préférable d'utiliser dans la mesure du possible la propriété pixelSize à la place de pointSize pour garantir un résultat identique.

À part cela, on constate que le code QML, combiné à un peu de JavaScript, est aussi bien découpé qu'architecturé. Dans la partie C++, le framework Qt est exploité à bon escient, rien à dire.

Gestion des structures de données 3 3 Bonne utilisation des Repetaters côté QML et utilisation côté C++ de plusieurs classes mettant chacune en place un modèle personnalisé. La gestion des structures de données répond bien aux besoins de l'application.
Gestion de la mémoire 2 0,5 Grosses fuites de mémoire du côté QML. Le responsable est l'élément Loader qui charge le fichier QML GameArea.qml à chaque fois que l'utilisateur demande à lancer une nouvelle partie, sans libérer la mémoire utilisée par le précédent fichier GameArea.qml chargé. Cela va créer un nombre croissant de viewports, de ChessEngines, etc., ce qui forme à la longue d'énormes fuites de mémoire (lors des tests effectués, une moyenne de 5 Mo de fuites a été constatée par clic sur le bouton de nouvelle partie). Toujours lors de la création d'une nouvelle partie, on constate que les pièces graphiques créées avec factory.createObject() ne sont pas non plus libérées. L'idéal serait de ne pas passer par un Loader dans ce cas de figure mais d'appeler des fonctions de réinitialisation, tout en pensant à libérer la mémoire allouée pour les pièces s'il est question de les recréer. Le cas échéant, si l'on souhaite passer par un Loader, bien penser à libérer la mémoire allouée à tous les éléments instanciés avant de charger un nouveau fichier.
Documentation minimale 1 1 Des commentaires dans tous les fichiers C++ et QML pour détailler le fonctionnement ou l'utilité de divers éléments du code.
Fonctionnalités obligatoires Total : 14 12,5  
Règles standard 10 8,5 Les règles sont toutes correctement implémentées, hormis quelques règles de pat telles que la règle des cinquante coups ou la règle de triple répétition de déplacement.
Mode de jeu 1 contre 1 4 4 Un mode humain contre humain est disponible et est à même de permettre à deux personnes de disputer une partie tout à fait respectable.
Bonus (critères facultatifs) Total : + 38 + 9  
Documentation en suffisance 2 0 Une documentation minimale est en place.
Module réseau pour jouer à distance 3 0 Fonctionnalité non implémentée.
Utilisation d'une IA externe 3 0 Aucune IA externe utilisée.
Implémentation d'une IA 9 0 Fonctionnalité non implémentée.
Mode 3D 6 5 L'échiquier est représenté en 3D par le biais du module Qt3D, utilisant OpenGL. Des possibilités de rotation et de zoom sont présentes, tout comme des animations 3D.
Utilisation des capteurs accessibles sur le périphérique cible 5 0 Fonctionnalité non implémentée.
Comptes utilisateur et gestion des scores en ligne 3 0 Fonctionnalité non implémentée.
Animation de jeu 2 2
De nombreuses animations de jeu contribuent à l'esthétisme de l'application :
  • lors de la sélection, la pièce élue se met à se scaler/déscaler, tout comme les indicateurs de déplacement et de menace ;
  • le déplacement des pièces est progressif et suit un chemin particulier, aucune pièce ne se percute ;
  • le fou avance en zigzags, le roi/piont en ligne droite, le cavalier décolle et retombe, la tour s'incline, s'avance et se remet droite et la reine tourne sur elle-même ;
  • le plateau pivote lors d'un changement de tour (blancs/noirs).
Surprenez-nous ! 5 2 L'application est dans sa globalité assez poussée et très intéressante. L'interface graphique de promotion est plutôt bien faite, les indicateurs sont utiles et les pièces prises sont stockées graphiquement à côté de l'échiquier. L'intégration d'une AI, maison ou externe, aurait cependant été très appréciée. La participation reste tout de même très satisfaisante.
Malus Total : -16 0  
Utilisation d'un autre langage (sont autorisés tous les langages qui peuvent utiliser Qt directement [C++, Python, Java...] ainsi que tous les langages que Qt utilise [en ce compris ECMAScript/JavaScript, QML, (X)HTML, Lua via QtLua/LQt, etc.]) hors communication avec une IA. -4 0 La règle est respectée.
Utilisation d'une autre bibliothèque non prévue pour Qt hors éventuelle IA (comme GNU chess). -4 0 La règle est respectée.
Application peu robuste -2 0 Aucun problème de ce type n'a été rencontré.
Application semblant plantée -2 0 Aucun problème de ce type n'a été rencontré.
Erreurs à la compilation -2 0 Aucun problème de ce type n'a été rencontré.
Avertissements à la compilation (sauf si justification dans le README) -1 0 Aucun problème de ce type n'a été rencontré.
Fichiers inutiles dans l'archive -1 0 La règle est respectée.

III-C. Juré 15

Critère Points à accumuler
(48 au total)
54,5  
Fonctionnement minimal du programme Total : 20 17  
Fonctionnement de base 8 8 Rien à dire.
Interface graphique 6 5 La partie 3D est super. L'habillage un peu moins. Les bouttons de contrôle ne sont pas terribles…
Fluidité 6 4 La visualisation est très fluide, bien que les animation sont très saccadées (mais j'ai l'impression que c'est dû à ma machine).
Qualité du code Total : 14 13,5  
Qualité d'un point de vue du code 4 4 Très propre. Le nombre de classes et le découpage me semble très pertinent.
Qualité d'un point de vue Qt 4 4 Rien vue de choquant. L'exploitation de QML est très propre.
Gestion des structures de données 3 3 Le code est très propre.
Gestion de la mémoire 2 1,5 Au lieu des pointeurs bruts, j'aurais préféré des pointeurs intelligents (le QVector<QVector<Piece*>>)
Documentation minimale 1 1 On a toutes les infos pour la recompiler.
Fonctionnalités obligatoires Total : 14 14  
Règles standard 10 10 Les règles sont implémentées.
Mode de jeu 1 contre 1 4 4 OK.
Bonus (critères facultatifs) Total : + 38    
Documentation en suffisance 2 1 Il faudrait un peu plus de doc sur les classes.
Module réseau pour jouer à distance 3 0  
Utilisation d'une IA externe 3 0  
Implémentation d'une IA 9 0  
Mode 3D 6 6 Nickel.
Utilisation des capteurs accessibles sur le périphérique cible 5 0  
Comptes utilisateur et gestion des scores en ligne 3 0  
Animation de jeu 2 0 Problème de fluidité des animations sur la machine de tests.
Surprenez-nous ! 5 3 Pour QML3D, le mode menaces et la prévisualisation des mouvements possible de la pièce.
Malus Total : -16 0  
Utilisation d'un autre langage (sont autorisés tous les langages qui peuvent utiliser Qt directement [C++, Python, Java...] ainsi que tous les langages que Qt utilise [en ce compris ECMAScript/JavaScript, QML, (X)HTML, Lua via QtLua/LQt, etc.]) hors communication avec une IA. -4 0  
Utilisation d'une autre bibliothèque non prévue pour Qt hors éventuelle IA (comme GNU chess). -4 0  
Application peu robuste -2 0  
Application semblant plantée -2 0  
Erreurs à la compilation -2 0  
Avertissements à la compilation (sauf si justification dans le README) -1 0  
Fichiers inutiles dans l'archive -1 0  

III-D. Moyenne

Critère Points à accumuler
(48 au total)
51
Fonctionnement minimal du programme Total : 20 17,67
Fonctionnement de base 8 7,67
Interface graphique 6 4,67
Fluidité 6 5,33
Qualité du code Total : 14 11,5
Qualité d'un point de vue du code 4 3
Qualité d'un point de vue Qt 4 3,5
Gestion des structures de données 3 3
Gestion de la mémoire 2 1
Documentation minimale 1 1
Fonctionnalités obligatoires Total : 14 13,167
Règles standard 10 9,167
Mode de jeu 1 contre 1 4 4
Bonus (critères facultatifs) Total : + 38 + 8,67
Documentation en suffisance 2 0,33
Module réseau pour jouer à distance 3 0
Utilisation d'une IA externe 3 1,75
Implémentation d'une IA 9 0
Mode 3D 6 5,33
Utilisation des capteurs accessibles sur le périphérique cible 5 0
Comptes utilisateur et gestion des scores en ligne 3 0
Animation de jeu 2 1,33
Surprenez-nous ! 5 1,67
Malus Total : -16 -0
Utilisation d'un autre langage (sont autorisés tous les langages qui peuvent utiliser Qt directement [C++, Python, Java...] ainsi que tous les langages que Qt utilise [en ce compris ECMAScript/JavaScript, QML, (X)HTML, Lua via QtLua/LQt, etc.]) hors communication avec une IA. -4 0
Utilisation d'une autre bibliothèque non prévue pour Qt hors éventuelle IA (comme GNU chess). -4 0
Application peu robuste -2 -0
Application semblant plantée -2 -0
Erreurs à la compilation -2 0
Avertissements à la compilation (sauf si justification dans le README) -1 -0
Fichiers inutiles dans l'archive -1 0

IV. redkite

Moyenne obtenue : 28,92 / 48.

Les sources.

IV-A. Juré 13

Critère Points à accumuler
(48 au total)
25 Dommage, c'était une bonne base, mais il semble y avoir eu un grand manque de temps.
Fonctionnement minimal du programme Total : 20 12  
Fonctionnement de base 8 4 La base est là, mais le seul avantage par rapport à un vrai échiquier est qu'on remet les pièces en deux clics – un peu light. (D'ailleurs, il est étonnant que les pièces ne soient pas déjà posées sur le plateau dès le lancement du programme.)
Interface graphique 6 2 Très basique : le minimum vital, sans plus ; toutes les fonctionnalités présentes ne sont pas implémentées (comme les timers). Très peu d'animations, on ne voit pas les cases possibles pour une pièce (injouable pour un vrai débutant aux échecs). D'ailleurs, il faut un certain temps pour comprendre qu'on peut commencer à jouer et que c'est aux blancs d'y aller – si on fait une pause et qu'on revient, on ne peut déterminer que par essai-erreur si c'est aux noirs ou aux blancs de jouer.
Fluidité 6 6 Vu la légèreté, il aurait été difficile de faire moins fluide.
Qualité du code Total : 14 8  
Qualité d'un point de vue du code 4 2 Commenté quand nécessaire, compréhensible. Gestion de la visibilité pas forcément très fine (exemple : queen.cpp:foundAllowedDestinations(), inutile de laisser destinationSquareName et destinationPiece accessibles dans toute la méthode, ces variables ne sont accessibles que dans la boucle interne.
Qualité d'un point de vue Qt 4 2 Les cases sont gérées une à une dans un fichier QML : quid des modèles ? D'où un fichier d'un millier de lignes très redondantes.
Gestion des structures de données 3 2 On remarque que des chaînes de caractères sont utilisées pour les positions, ce qui ne fait pas très propre (ce ne sont pas des caractères, mais bien des cases d'un échiquier).
Gestion de la mémoire 2 1,5 Quelques blocs mémoires pourraient encore être libérés.
Documentation minimale 1 0,5 On aurait notamment apprécié plus de détails dans les méthodes à implémenter dans Piece, les contrats à respecter.
Fonctionnalités obligatoires Total : 14 6  
Règles standard 10 3 Toutes les règles ne sont pas implémentées, loin de là (même pas le mat).
Mode de jeu 1 contre 1 4 3 Correctement implémenté, mais support insuffisant des règles.
Bonus (critères facultatifs) Total : + 38 0  
Documentation en suffisance 2 0  
Module réseau pour jouer à distance 3 0  
Utilisation d'une IA externe 3 0  
Implémentation d'une IA 9 0  
Mode 3D 6 0  
Utilisation des capteurs accessibles sur le périphérique cible 5 0  
Comptes utilisateur et gestion des scores en ligne 3 0  
Animation de jeu 2 0  
Surprenez-nous ! 5 0  
Malus Total : -16 -1  
Utilisation d'un autre langage (sont autorisés tous les langages qui peuvent utiliser Qt directement [C++, Python, Java...] ainsi que tous les langages que Qt utilise [en ce compris ECMAScript/JavaScript, QML, (X)HTML, Lua via QtLua/LQt, etc.]) hors communication avec une IA. -4 0  
Utilisation d'une autre bibliothèque non prévue pour Qt hors éventuelle IA (comme GNU chess). -4 0  
Application peu robuste -2 -1 Plantage après la prise du roi.
Application semblant plantée -2 0  
Erreurs à la compilation -2 0  
Avertissements à la compilation (sauf si justification dans le README) -1 0  
Fichiers inutiles dans l'archive -1 0  

IV-B. Juré 14

Critère Points à accumuler
(48 au total)
22,75  
Fonctionnement minimal du programme Total : 20 11  
Fonctionnement de base 8 3 Une application simple mais efficace avec la gestion d'une partie humain contre humain. On peut constater avec les divers TODO et certains éléments graphiques non utilisés tels que les timers dans le dock que la participation aurait pu recevoir plus de fonctionnalités (gestion des scores, historique des coups, limites de temps, etc.), rendant l'application plus intéressante. Attention à l'implémentation des règles où plusieurs points essentiels sont implémentés mais non fonctionnels.
Interface graphique 6 2 L'application, utilisant une declarative view et des éléments natifs, expose un échiquier bleu et blanc accompagné d'une barre de menus et d'un dock sur le côté. Ce dernier permet l'affichage des informations de jeu (mat, échec, etc.). Des animations discrètes sont présentes, telles qu'un effet d'opacité à la sélection d'une pièce. L'interface graphique aurait cependant pu être améliorée avec certaines informations telles que les pièces mettant le roi en échec ou bien une meilleure exploitation du dock ; celui-ci aurait par exemple pu afficher les pièces prises par chaque camp, le nombre de coups ou même des moyens d'interaction entre joueurs tels que la proposition de déclarer la partie nulle.
Fluidité 6 6 L'application, de sa nature légère, ne présente pas une interface graphique encombrée et n'effectue pas de calculs lourds, d'où son excellente fluidité.
Qualité du code Total : 14 9  
Qualité d'un point de vue du code 4 2

Le code suit des règles de codage, le rendant aussi facile à comprendre qu'agréable à lire. Des commentaires en anglais sont présents dans les parties où des explications peuvent être nécessaires pour expliquer telle ou telle partie de l'algorithme.

Du point de vue de la syntaxe elle-même du code, les mentions « const » sont souvent présentes. Toutefois, attention à ne pas en négliger les emplois devant les variables d'énumérations, les variables locales et les pointeurs (voir http://duramecho.com/ComputerInformation/WhyHowCppConst.html). Trois illustrations où les mentions sont à ajouter:

 
Sélectionnez
Piece * Board::addPiece(Piece::Type type, Piece::Color color, const QString &squareName) 
    /* Avec la mention const et l'emploi de références : 
        Piece * Board::addPiece(const Piece::Type &type, const Piece::Color &color, const QString &squareName) */
bool isWhitePiece = piece.getColor() == Piece::White; 
    /* Avec la mention : const bool isWhitePiece = piece.getColor() == Piece::White; */
Board::Board(QWidget *parent) : QDeclarativeView(QUrl("qrc:/board.qml"), parent), 
    /* Avec la mention : Board::Board(QWidget* const parent) */

Certaines conditions ternaires ne sont pas exploitées pour une affectation ou bien leur un retour n'est pas utilisé. Préférer dans ces cas l'emploi d'une simple paire if/else pour éviter des conversions implicites de type possibles dans le cas où les fonctions ne retourneraient pas void. Par exemple :

 
Sélectionnez
isWhiteMoving?emit whiteMoveStarted():emit blackMoveStarted();

Au niveau de l'architecture du code, une classe Board joue le rôle du gestionnaire global de l'application. Il gère la partie humain contre humain, le déplacement des pièces, le nombre de coups effectués, etc. Il est aussi marqué en TODO qu'il aurait également pu gérer la promotion des pions. Au final, on a une classe qui s'écarte du principe de responsabilité unique. Il serait préférable de réaliser une arborescence de classes plus ample afin d'attribuer à chacune un rôle bien précis et donc d'obtenir des apports conséquents par rapport à la complexité et la lisibilité du code.

Qualité d'un point de vue Qt 4 3 Les classes de Qt sont utilisées à bon escient du côté Core comme du côté GUI de l'application. Le module Qt Declarative est bien exploité pour la réalisation de l'interface graphique et pour les interactions avec l'utilisateur. Le mécanisme de signaux/slots est exploité afin de permettre une communication entre les diverses classes. Bon travail. Attention à bien exploiter toutes les possibilités de QML en utilisant par exemple un système de modèle pour afficher la grille en une fois plutôt que de gérer les cases une à une.
Gestion des structures de données 3 2 Les pièces sont stockées dans une QList de pièces. La position des pièces est stockée dans un QHash associant une QString représentant une position de l'échiquier à une pièce. L'approche est correcte et permet une implémentation simple des diverses règles de déplacement des pièces.
Gestion de la mémoire 2 1,5 La mémoire allouée pour les pièces en début de partie est bien libérée lors de la suppression d'une pièce ou bien le lancement d'une nouvelle partie, ce qui ne laisse pas la place aux fuites de mémoire. Cependant, il reste possible de libérer la mémoire allouée pour des éléments tels que les Player* à l'initialisation de l'application mais jamais libérée.
Documentation minimale 1 0,5 Des commentaires sont présents pour détailler certaines étapes de l'algorithme mis en place.
Fonctionnalités obligatoires Total : 14 3,5  
Règles standard 10 1,5

Les déplacements élémentaires des pièces sont présents. Cependant, de nombreux points sont à reprendre/mettre en place :

  • le mat et le pat ne fonctionnent pas, on peut prendre le roi et continuer de jouer ;
  • l'échec est détecté mais n'empêche pas le joueur d'effectuer des mouvements non autorisés (un cavalier peut se déplacer et mettre en échec son roi, ce dernier pouvant entrer dans le champ d'action d'une tour et se mettre lui-même en position d'échec, etc.) ;
  • la prise en passant et la promotion d'un pion ne sont pas implémentées ;
  • le petit roque chez les blancs n'est pas fonctionnel, on ne peut pas effectuer le mouvement à moins de déplacer le roi de la position initiale (E1) à la position F1 puis de déclencher le roque en le déplaçant en G1.
  • il est possible de roquer plusieurs fois : les conditions de roque ne sont pas respectées.
  • la règle des cinquante coups n'est pas implémentée (tout comme d'autres règles de pat) : si 50 coups sont effectués depuis la dernière prise ou déplacement d'un pion, un match nul peut être proposé.
Mode de jeu 1 contre 1 4 2 Le mode de jeu humain contre humain est correctement implémenté. Cependant, à cause de l'imperfection de l'implémentation des règles standard, il ne permet pas d'être exploité dans le cadre d'une partie sérieuse.
Bonus (critères facultatifs) Total : + 38 +0,25  
Documentation en suffisance 2   Des commentaires pris en compte dans la partie Documentation minimale, sans plus.
Module réseau pour jouer à distance 3 0 Fonctionnalité non implémentée.
Utilisation d'une IA externe 3 0 Fonctionnalité non implémentée.
Implémentation d'une IA 9 0 Fonctionnalité non implémentée.
Mode 3D 6 0 Fonctionnalité non implémentée, l'affichage est réalisé en 2D avec le module Qt Declarative.
Utilisation des capteurs accessibles sur le périphérique cible 5 0 Fonctionnalité non implémentée.
Comptes utilisateur et gestion des scores en ligne 3 0 Fonctionnalité non implémentée.
Animation de jeu 2 0,25 Des animations discrètes d'opacité lors de la sélection de pièces afin d'indiquer la pièce actuellement sélectionnée.
Surprenez-nous ! 5 0 La participation a apparemment rencontré un manque de temps, entraînant un fonctionnement de base incomplet. De ce fait, rien de vraiment surprenant par rapport à ce qui a été demandé.
Malus Total : -16 -1  
Utilisation d'un autre langage (sont autorisés tous les langages qui peuvent utiliser Qt directement [C++, Python, Java...] ainsi que tous les langages que Qt utilise [en ce compris ECMAScript/JavaScript, QML, (X)HTML, Lua via QtLua/LQt, etc.]) hors communication avec une IA. -4 0 La règle est respectée.
Utilisation d'une autre bibliothèque non prévue pour Qt hors éventuelle IA (comme GNU chess). -4 0 La règle est respectée.
Application peu robuste -2 -1 L'application crashe après une prise du roi, au tour suivant du possesseur du feu roi.
Application semblant plantée -2 0 Aucun problème de ce type n'a été rencontré.
Erreurs à la compilation -2 0 Aucun problème de ce type n'a été rencontré.
Avertissements à la compilation (sauf si justification dans le README) -1 0 Aucun problème de ce type n'a été rencontré.
Fichiers inutiles dans l'archive -1 0 Aucun problème de ce type n'a été rencontré.

IV-C. Juré 15

Critère Points à accumuler
(48 au total)
39  
Fonctionnement minimal du programme Total : 20 13  
Fonctionnement de base 8 6 On a du mal à savoir quel couleur doit jouer. Au début, je pensais que rien ne bougeait.
Interface graphique 6 4 Sobre mais suffisant.
Fluidité 6 3 Problème pour savoir si un pion est sélectionné.
Qualité du code Total : 14 12  
Qualité d'un point de vue du code 4 3 Code propre. Bon découpage en classes. Des tests un peu bizzares comme bool isWhitePiece = piece.getColor() == Piece::White; Quelques oublis d'initialisation comm dans addPiece : Piece *piece;
Qualité d'un point de vue Qt 4 4 Bon mélange C++ et QML.
Gestion des structures de données 3 3 Correct.
Gestion de la mémoire 2 2 Rien à dire.
Documentation minimale 1 1 Un peu de présentation et d'explications n'auraient été pas mal.
Fonctionnalités obligatoires Total : 14 14  
Règles standard 10 10 Je n'ai pas vu de règle manquante.
Mode de jeu 1 contre 1 4 4  
Bonus (critères facultatifs) Total : + 38 0  
Documentation en suffisance 2 0  
Module réseau pour jouer à distance 3 0  
Utilisation d'une IA externe 3 0  
Implémentation d'une IA 9 0  
Mode 3D 6 0  
Utilisation des capteurs accessibles sur le périphérique cible 5 0  
Comptes utilisateur et gestion des scores en ligne 3 0  
Animation de jeu 2 0  
Surprenez-nous ! 5 0  
Malus Total : -16 0  
Utilisation d'un autre langage (sont autorisés tous les langages qui peuvent utiliser Qt directement [C++, Python, Java...] ainsi que tous les langages que Qt utilise [en ce compris ECMAScript/JavaScript, QML, (X)HTML, Lua via QtLua/LQt, etc.]) hors communication avec une IA. -4 0  
Utilisation d'une autre bibliothèque non prévue pour Qt hors éventuelle IA (comme GNU chess). -4 0  
Application peu robuste -2 0  
Application semblant plantée -2 0  
Erreurs à la compilation -2 0  
Avertissements à la compilation (sauf si justification dans le README) -1 0  
Fichiers inutiles dans l'archive -1 0  

IV-D. Moyenne

Critère Points à accumuler
(48 au total)
28,92
Fonctionnement minimal du programme Total : 20 12
Fonctionnement de base 8 4,33
Interface graphique 6 2,67
Fluidité 6 5
Qualité du code Total : 14 9,67
Qualité d'un point de vue du code 4 2,33
Qualité d'un point de vue Qt 4 3
Gestion des structures de données 3 2,33
Gestion de la mémoire 2 1,67
Documentation minimale 1 0,33
Fonctionnalités obligatoires Total : 14 7,83
Règles standard 10 4,83
Mode de jeu 1 contre 1 4 3
Bonus (critères facultatifs) Total : + 38 + 0,0833
Documentation en suffisance 2 0
Module réseau pour jouer à distance 3 0
Utilisation d'une IA externe 3 0
Implémentation d'une IA 9 0
Mode 3D 6 0
Utilisation des capteurs accessibles sur le périphérique cible 5 0
Comptes utilisateur et gestion des scores en ligne 3 0
Animation de jeu 2 0,0833
Surprenez-nous ! 5 0
Malus Total : -16 -0,67
Utilisation d'un autre langage (sont autorisés tous les langages qui peuvent utiliser Qt directement [C++, Python, Java...] ainsi que tous les langages que Qt utilise [en ce compris ECMAScript/JavaScript, QML, (X)HTML, Lua via QtLua/LQt, etc.]) hors communication avec une IA. -4 0
Utilisation d'une autre bibliothèque non prévue pour Qt hors éventuelle IA (comme GNU chess). -4 0
Application peu robuste -2 -0,67
Application semblant plantée -2 -0
Erreurs à la compilation -2 0
Avertissements à la compilation (sauf si justification dans le README) -1 -0
Fichiers inutiles dans l'archive -1 0
Les défis Qt, page générales
La page d'accueil
Les règles
Dépôt des projets
Le forum des défis
Le premier défi Qt : le Buddhabrot
Le sujet
Les résultats
Le Buddhabrot sur le forum
Le deuxième défi Qt : l'application mobile pour hôpital
Le sujet
Les résultats
L'application mobile sur le forum
Le troisième défi Qt : un jeu d'échecs
Le sujet
Un jeu d'échecs sur le forum
Les résultats
  

Copyright © 2012 Developpez.com. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts. Droits de diffusion permanents accordés à Developpez LLC.