Jeu Splendor en Java

Objectif du projet

Réaliser une implémentation du jeu de société Splendor en Java, jouable dans la console : de 2 à 4 joueurs, un joueur humain face à des robots. Ce projet était l'occasion de mettre en pratique la programmation orientée objet (classes, héritage, interfaces) sur un jeu aux règles bien définies.

Ma démarche

J'ai commencé par repérer les éléments du jeu (plateau, cartes, ressources, joueurs, actions), puis j'ai attribué à chacun une classe. J'ai ensuite construit le déroulement d'une partie autour d'elles.

1. Modéliser les éléments du jeu : les ressources (Resource, Resources), les cartes de développement (DevCard) et le plateau (Board).
2. Modéliser les joueurs : une classe abstraite Player dont héritent HumanPlayer et DumbRobotPlayer.
3. Représenter chaque action possible par une classe grâce à l'interface Action.
4. Écrire la boucle de jeu dans la classe Game : les tours, la limite de jetons et la fin de partie.

Réalisation du projet

Une architecture orientée objet

• Les joueurs : Player est une classe abstraite qui regroupe ce qui est commun (nom, points, jetons, cartes achetées). Le joueur humain choisit son action dans la console, alors que le robot suit une stratégie simple et prédéterminée.
• Les actions : l'interface Action impose une méthode process, implémentée par BuyCardAction, PickSameTokensAction, PickDiffTokensAction, DiscardTokensAction et PassAction. La classe Game n'a donc pas besoin de savoir quelle action est jouée : elle appelle simplement process.
• Le plateau : il gère les piles de cartes par niveau, les cartes visibles et le stock de jetons. Les cartes sont lues depuis un fichier stats.csv (97 lignes : 40 cartes de niveau 1, 30 de niveau 2, 20 de niveau 3 et 8 nobles), puis mélangées au lancement.

Le déroulement d'une partie

• Choix du nombre de joueurs (de 2 à 4) et saisie des noms : un joueur humain et des robots pour les autres places.
• À chaque tour, le joueur peut acheter une carte, prendre deux jetons identiques, prendre trois jetons différents ou passer.
• Si un joueur dépasse 10 jetons, il doit en défausser.
• La partie s'arrête lorsqu'un joueur atteint 15 points, et le ou les gagnants sont annoncés.

L'affichage

Le plateau et l'état des joueurs sont dessinés dans la console à l'aide de tableaux de chaînes de caractères que l'on assemble (interface Displayable), avec une flèche pour indiquer le joueur dont c'est le tour. La fenêtre d'affichage (classe Display) nous était fournie.

Problèmes rencontrés

• Problème : Le coût réel d'une carte dépend des cartes déjà possédées, puisque chacune apporte une réduction permanente sur une ressource.

  Solution : Calculer le coût à payer ressource par ressource, en déduisant ce que fournissent les cartes du joueur (sans jamais descendre sous zéro), avant de mettre à jour les stocks du joueur et du plateau.

• Problème : Vérifier les choix du joueur humain (carte trop chère, ressource épuisée, même ressource choisie deux fois).

  Solution : Contrôler chaque saisie avant d'appliquer l'action et afficher un message d'erreur pour redemander le choix.

• Problème : Faire jouer un robot sans écrire une intelligence artificielle complète.

  Solution : Lui donner une stratégie simple par ordre de priorité : acheter une carte si possible, sinon prendre des jetons, sinon passer.

Ce que j'en retiens

Ce projet m'a fait voir l'intérêt de l'héritage et des interfaces : ajouter un type de joueur ou une nouvelle action se fait sans toucher à la boucle de jeu. Il reste des pistes pour aller plus loin : un robot plus malin, la gestion des nobles déjà présents dans le fichier de cartes, ou encore la réservation de cartes.