Discussion :

[Invité]

Bonjour !

Nous sommes deux étudiants apprenant le C++ sur notre temps libre. On a commencé la semaine dernière à travailler ensemble sur un petit jeu en tour par tour qui s’utilise en ligne de commande.

Le but est simple, on incarne un personnage (un mage ou un chevalier) et on doit affronter des ennemis (Gobelins et/ou Trolls). On gagne de l’xp en tuant des ennemis ce qui permet de passer des niveaux et d’améliorer nos compétences (points de vie, armure/bouclier ou les dégâts) et aussi d’augmenter la difficulté du jeu par la même occasion.

Le lien github : https://github.com/Haulun/Console_Turn_Based_Game

On aimerait, si c’est possible, avoir des retours sur la structure de notre code, positifs comme négatifs. On veut savoir si on part dans une mauvaise direction ou s' il y a une erreur qui pourrait nous porter préjudice plus tard par exemple.

Pour l’instant notre projet est très simple :
On a un fichier main.cpp avec une boucle while qui gère le tour par tour tant que le joueur n’est pas mort.
On a :
Une classe Entity
Deux classes Hero et Enemy qui héritent de Entity.
Deux classes Knight et Mage qui héritent de Hero
Et deux classes Goblin et Troll qui héritent de Enemy.


L’objectif de ce petit jeu, est d’apprendre le C++ tout en pratiquant.
Sur le long terme, il nous permettrait de créer des jeux un peu plus évolués qu’un simple jeu console.

Cordialement

[Mat.M]

bonsoir d'une manière générale on ne code jamais "en dur" des constantes par exemples les points de vie ( entity.cpp)
Au besoin il faut charger un fichier de données pour cela mais éviter de mettre des constantes en dur.
Après lorsqu'on maitrise un peu plus la programmation, avoir recours éventuellement à un outil de scripting comme Lua afin de paramétrer.

Ou bien un fichier XML à charger et lire avec des balises comme <points_vie>100</points_vie> <mana>90</mana> par exemple (il y a TinyXML pour charger un fichier xml)

Mais avant d'engager la grosse artillerie c'est certain qu'il faut apprendre pas-à-pas.

[LittleWhite]

Bonjour,

S'il vous plaît, ajoutez un Makefile, ou même mieux, un CMake.
Il y a des avertissements à la compilation.

C'est une bonne chose d'utiliser Git et GitHub . Les messages de commits ne sont pas super explicites.
Le main() est assez conséquent. Certains diraient qu'il ne sert qu'à gérer les arguments de l'exécutable et lancer correctement le programme.

Utilisez des pointeurs intelligents.
La classe Entity me semble faire trop chose (voir le principe de responsabilité unique).

Les std::string sont passés en copie (donc perte de temps passé à copier des chaînes).
Regardez l'utilisation du mot clef override ou final.
Des commentaires ou de la documentation utile serait un plus .

La méthode absorbDmg du Knight et du Mage font la même chose. Pareil du côté des Enemies.
Au final, les classes Knight, Mage, Goblin et Troll ne sont pas vraiment utiles.

Je suis d'accord avec les remarques de Mat.M. Évolution possible : lire les caractéristiques depuis des fichiers.

On ne peut pas quitter le jeu (genre, choix 'q' pour quitter).
En évolution possible, on peut imaginer une meilleure interface (ncurses), ou simplement une interface qui efface ce qui est écrit (sinon, c'est dur à lire/voir les évolutions de la partie).

Bonne continuation.

[ohnomorejmmings]

Mais avant d'engager la grosse artillerie c'est certain qu'il faut apprendre pas-à-pas.

En effet mais je te rejoins concernant l'intérêt de séparer les données du code. Rien que gérer les arguments de la ligne de commande est un bon début. Ensuite on peut passer à un simple fichier au format texte. De très bons exercices pour apprendre la gestion des flux en C++ ! Pourquoi pas un fichier par monstre, un pour le PJ évidemment, un pour configurer une partie facile et l'autre plus difficile… Ça permet ensuite de partir sur des améliorations vraiment intéressantes !

Vive les JDRs.

PS : Ne pas hésiter à rechercher les autres projets car le genre plait

[Invité]

Bonjour,
Nous sommes deux étudiants apprenant le C++ pendant notre temps libre.

Nous avons déjà envoyé un message sur 3 forums différents et sur 2 discords orientés programmation en parlant du petit jeu tour par tour qu’on a créé dans le but d’apprendre le C++. Avec tous les retours que nous avons obtenus, nous avons pu progresser et apprendre de nos erreurs (merci beaucoup!). Nous avons suivi les conseils bien qu’il y ait encore des zones floues que nous allons aborder ici en espérant avoir des réponses précises et compréhensibles.


Il y a en tout, dans notre projet, 5 fichiers. Les voici :

• main.cpp
• game.hpp / game.cpp
• entity.hpp / entity.cpp

Et comme toujours, voici notre github où vous pouvez retrouver le code :
https://github.com/Haulun/Console_Turn_Based_Game


D’abord, ce que nous avons pu tirer de tous les conseils reçus :

• Nous avons ajouté des fonctions pour éviter d’avoir un gros pavé de +150 lignes.
• Nous avons rajouté le makefile pour ceux qui le voulaient.
• Nous avons créé une classe dédiée au jeu, le main servant à exécuter le programme.
• Nous avons appris ce qu'étaient les “unique_ptr” et nous les avons utilisés (voir ci-dessous).
• Nous avons supprimé les classes filles inutiles au fonctionnement du jeu (c’est-à-dire, toutes ! Il ne nous reste plus que la classe Entity).
• Nous avons fait en sorte que l’interface de jeu soit meilleure et plus lisible (les textes précédents inutiles s’effacent).
• Nous avons fait en sorte que le joueur puisse quitter le jeu n’importe quand.
• Nous avons initialisé par défaut nos variables membres lors de la déclaration.
• INFO : Nous avons aucun warning, ni d’erreurs de compilation, ni d’erreurs à l’exécution !

Et voilà, cependant, les zones encore floues pour nous :

• Nous utilisons peut-être mal les unique_ptr. Nous ne voyons en fait aucune différence avec les pointeurs qu’on utilisait précédemment (avec “ new ” et “delete ”) car pour les unique_ptr, il nous semble qu’il faut utiliser “ reset() ” pour supprimer l’objet (que ce soit avant la fin du programme ou pour mettre un autre objet à la place du précédent) donc les questions qu’on se pose sont:
  - Pourquoi utiliser unique_ptr au lieu de pointeurs ‘‘normaux’’, quelles sont les différences ?
  - Les utilisons-nous mal ?
  - Dans la fonction terminateGame() dans la classe Game, sont-ils vraiment nécessaires ou les derniers objets sont directement détruits à la fin du programme avec les unique_ptr ?
  - Les fonctions make (makeTroll(), makeGoblin, etc...) et chooseHero() sont-elles correctes ?
  
• De plus, nous avons reçu un message concernant cela mais, nous avons du mal à savoir comment faire autrement que de mettre une dizaine de getters et/ou setters dans la classe Entity pour récupérer les informations des entités ou pour les modifier.
  - Est-ce vraiment nécessaire ?
  - Si oui, avez-vous des choses à nous conseiller ?
  
• En outre, pensez-vous (on nous avait déjà fait la remarque) que nos classes Entity et Game sont trop surchargées (principe de responsabilité unique ?).
  
• Enfin, dans la fonction Game::enemyChooseAction() nous utilisons la fonction heal() à la fois comme booléen pour une condition if et comme action de se heal, pensez-vous que cette façon de faire est correcte ou faudrait-il rajouter une fonction “ bool healable() ” ?

Il y a cependant des remarques que nous n’avons pas encore implémentées et que nous comptons probablement ajouter:

1. Passer toutes les variables (vie, shield, etc) dans un fichier XML indépendant.
2. Ajouter un Cmake
3. Utiliser ncurses pour l’interface

Voilà l'avancée, j’espère que vous pourrez nous aider autant que la première fois car ça nous a vraiment permis de progresser et d’en apprendre davantage sur le C++.


Cordialement.

[fmartini]

Pourquoi utiliser unique_ptr au lieu de pointeurs ‘‘normaux’’, quelles sont les différences ?
Un unique_ptr ne peut pas être copié vers un autre unique_ptr. Il peut uniquement être déplacé. Étant donné qu'il est recommandé de restreindre les pointeurs à un seul propriétaire pour éviter de complexifier un programme.
Personnellement je m'en passe. En respectant correctement les principaux Design Pattern implémenté dans un programme, on s'en sort assez bien sans.

Les utilisons-nous mal ?
Je pense qu'il est nécessaire que toi et ton camarade, passiez faire un tour au niveau des design pattern pour avoir les "bonnes manières" du codage. C'est assez universel dans le POO donc c'est toujours bon à prendre.
Voici un site que je conseille souvent (systématiquement) à mes stagiaires BTS Info. Certes ce n'est pas sur le forum et j'espère que la communauté m'en excusera. Mais la simplicité des explications font que ces cours sont d'une rare qualité pour les débutants. Même si a terme, il sera préférable que toi et ton camarade soyez en mesure de lire une documentation officielle (et le fameux RTFM).

En outre, pensez-vous (on nous avait déjà fait la remarque) que nos classes Entity et Game sont trop surchargées (principe de responsabilité unique ?).

cf : plus haut sur les Design Pattern.
Toi et ton camarade pouvez également vous pencher sur les diagrammes UML. C'est toujours plus confortable de structurer un programme bien avant de commencer à le coder.

Je pense pas avoir apporter de réponse direct à tes questions. Cependant, comme en école d'ingé, je te redirige vers des sujets qui te servirons a toi et ton camarade dans votre grande quête autodidacte.