Bonjour,

Je vous donne un peu de contexte avant d'entré dans le vif du sujet.

Je suis en L3 informatique et cette année nous avons notre premier cours de programmation orienté objet en Java19.

Pour l'instant nous avons vu en cours : les Classes/Record, les structures de contrôles chaine de caractère (String, StringBuilder), les collections (ArrayList, Map) les interfaces et les entré/sorties.

En outre, nous étudions la "composition" du langage (mot peu précis mais je n'en trouve pas d'autres). Nous avons également dans cette matière un projet à réaliser pour ce semestre. Le projet de cette année est de programmer en Java19 le jeu de plateau Patchwork (Règle du jeu en français au format PDF : https://ludos.brussels/ludo-cocof/opac_css/doc_num.php?explnum_id=1325) d'abord en version console puis une version graphique

Mon problème vis à vis de ce projet est la méthodologie à suivre afin de réaliser un projet propre avec du code maintenable. Je m'explique.

Pour le moment je n'ai rien codé car je préfère bien structuré l'architecture du projet avant de passer à programmer pour éviter de "pisser de la ligne". Je suis donc toujours à la phase d'écriture et c'est là où se situe mon problème. Plus précisément, j'ai juste écrit l'expression des besoins et j'ai également listé les mécanismes du jeu mais même là je ne suis pas sûr de la viabilité de ce que j'ai. Voici ce que j'ai écrit pour l'expression des besoins :

Pour tout les quadrillages:
0 = case vide
Entier > 0 



Patch :

-Longueur de la pièce : Entier length
-Largeur de la pièce : Entier width
-coût en bouton d'une pièce : Entier costButton
-Nombre de bouton qu'on gagne : Entier giveButton
-Nombre de case : Entier moveCell
-Entier qui indique une couleur (en prévision de la phase 3)
-Tableau en 2 dimensions d'entier de taille lengthXwidth qui décrit la géométrie de la pièce : 0 = case vide
											  * = case non vide représenté par un entier sauf 0
Exemple : **
	  ** (Carré)
	  00**00
	  0****0
	  00**00 


-Pour créer un deck, on utilise un fichier externe qui décrit les données de toute les pièce d'un deck
-Idée de formatage de donnée d'une pièce dans un fichier :
length width costButton giveButton moveCell color\n
x1,y1 x2,y2 (...) xn,yn\n
\n
length width costButton giveButton moveCell color\n
x1,y1 x2,y2 (...) xn,yn\n
.
.
.
\n


quiltBoard :

-Longueur du quadrillage : Entier length
-Largeur du quadrillage : Entier width
-length = width
-Tableau en 2 dimensions d'entier de taille lengthXwidth remplie de case vide au départ
 Ce tableau contiendra par la suite les pièces posé par un joueur.
 Exemple : 000000000			  **0000000
 	   000000000		          **0000000
 	   000000000                      000000000
 	   000000000 Joueur pose un carré 000000000
 	   000000000 	    --->          000000000
 	   000000000                      000000000
 	   000000000                      000000000
 	   000000000                      000000000
 	   000000000                      000000000
   (quilt bord début de game)
	

Deck :

-Pour identifier une pièce on lui associe un id dans le deck.
 Dictionnaire de patch (pièce) avec comme couple clé,valeur (idPatch, patch)

- Entier qui sert de neutral token, c'est à dire un entier qui est l'indice min d'où se trouve la première pièce disponible à l'achat durant le tour courant.
- Entier qui indique combien de pièce sont disponible à l'achat durant un tour. Dans les règles du jeu, il est écrit qu'on peut en choisir parmi 3 : Entier nbPiece
  Exemple : | = neutral Token
            pn = piece numéro n
            
            |p1 p2 p3 p4 p5 Dans cette configuration le joueur peut décider d'acheter soit p1 soit p2 soit p3 car le neutral token se trouve au niveau de p1 et on peut choisir parmi 3 pièces qui suit 
            le neutral token.
            p1 p2 |p3 p4 Ici le joueur peut décider d'acheter soit p3 soit p4 soit p1   
- Entier qui indique combien de pièce disponible il reste dans le deck (rajout)


Central Time Board :

- quiltBoard de 9x9 rempli de patch issue d'un deck
- Nombre de case du plateau : nbCell
- Tableau unidimensionnel d'entier de taille nbCell remplie de case vide qui représente le plateau du jeu.
- Liste des indices des cases où se trouvent les cases spéciales. (en prévision de la phase 2) 

TimeToken :

- Entier qui donne la position du token sur le plateau : Entier position
- Entier qui donne la couleur du token : color (en prévision de la phase 3)
- Entier qui indique la place du token par rapport à un autre. On considère qu'un token est devant si sa position est sup à l'autre. Cette entier vaut 0 si le token est premier 1 sinon.

Joueur :

- quiltBoard de 9x9 vide au départ
- Entier qui indique le nombre de boutons que possède le joueur : Entier nbButton
- Liste qui contenant les indices des pièces dans un deck que possède le joueur (vide au départ).
- TimeToken qui représente le jeton d'un joueur.
- Liste des pièces qu'à acheter le joueur (rajout)

En outre, je suis complètement perdu vis à vis de la méthodologie à suivre pour le développent d'un projet en utilisant la POO. Cela diffère complètement du développement de projet en C ou python des années précédente. Par exemple, je en vois pas comment et où on peut gérer l'interaction entre 2 objets différents (entre un Deck et un Joueur par exemple).

J'ai appris l'existence une méthode de structuration qui est MVC (je n'ai pas étudié ce que c'est en détail) qui semble répondre à mon interrogation précédente.

Mes questions sont les suivantes : quel(s) est/sont la/les méthodologie(s) à suivre pour bien structurer un projet en java ? Est ce que ça vaut le coup que j'apprenne ce que c'est la MVC pour le projet ?

J'espère que mes explications ne sont pas aussi confuses que mon esprit vis à vis de projet et je vous remercie d'avance pour votre aide.

Salut pour commencer tu as un probleme d'abstraction, tu melanges expression du besoin et detail d'implementation, ca devrait etre separe, aucun detail technique ne devrait s'y trouver, sinon tu risque fort d'avoir un resultat biaise par les contraintes techniques

une fois que tu as une expression de ton besoin, tu peux en sortir une version fonctionnelle: detail des ecrans, flux de donnees, algo de traitement...

et enfin de la, tu peux commencer ton implementation

Pour l'architecture, il est imperatif de separer la vue des traitements, c'est ce qui te permettra en outre de passer de console a gui par la suite

pour la decoupe des traitements, un package par domaine fonctionnel, sachant qu'il faut eviter les dependances circulaire (package a depend de B et B depend de A)

Idealement tu peux egalement avoir une separation plus fine en separant le fonctionnel des composants purement techniques, mais pour debuter ce n'est probablement pas judicieux.

Une bonne decoupe demande de l'experience, tu n' y arriveras pas du 1er coup et c'est normal.

Egalement, use et abuse des interface pour affaiblir le couplage entre les composants.

D'accord c'est beaucoup plus clair maintenant merci beaucoup ! J'ai néanmoins une question, vous avez parlé de "package par domaine fonctionnel" je n'ai pas tout à fais compris de quoi vous voulez parler.

un domaine est un regroupement de concepts lies autour d'une meme thematique, il peut etre soit independant d'autres domaines, soit lies a certains.

Pour donner un exemple concret, dans l'application que je developpe  actuellement, PXL, on trouvera comme domaines fonctionnels les jeux, les roms, les medias, les sauvegardes, les systemes de jeux, les utilisateurs, les themes, et bien d'autres.