Projet JEU DE GUERRE



1.1. Contraintes

Langage de programmation : C++

1.2. Groupes

1.3. Sujet

On dispose d'un plateau de jeu de 112 cases réparties sur 8 lignes par 14 colonnes.

Deux joueurs disposent initialement de 8 unités de combat composées de 3, 5, 7 ou 10 soldats qui vont s'affronter :

Soit un total de 50 soldats pour chaque joueur.

Au début, les unités de chaque joueur sont positionnées aléatoirement soit du côté droit (joueur 2, colonnes 10 à 14), soit du côté gauche (joueur 1, colonnes 1 à 5).

Jeu de Guerre

Le gagnant est le joueur qui possède le plus de soldats au bout de 100 tours de jeu ou celui qui réussit à éliminer toutes les unités de son adversaire en moins de 100 tours.

Chaque unité de combat se déplace en restant bien entendu sur l'aire de jeu :

Cela donne les 16 déplacements autorisés suivants :

...|...
.\.|./.
...|...
---*---
...|...
./.|.\.
...|...

On identifie les unités par des numéros :

Les unités se déplacent en utilisant les coordonnées (y,x) :

les règles d'engagement sont les suivantes :

1.4. Spécificités

Pour ce jeu, on va opposer un être humain à l'ordinateur et on réalisera un tournoi qui verra chaque équipe s'affronter. On établira un classement en fonction du nombre de victoires.

On vous demande :

  1. de mettre en place des structures de données et fonctions communes à tous les groupes de manière à pouvoir réaliser une compétition entre groupes de projet
  2. de développer une fonction de jeu pour l'ordinateur qui prendra les mêmes paramètres pour tous les groupes de projet et retournera l'unité à déplacer et la case de destination à partir d'une situation de jeu
  3. de tester que la fonction de jeu pour l'ordinateur fonctionne correctement

Il n’est pas nécessaire de développer une interface graphique.

1.5. Implantation

1.5.1. Modules

On va utiliser trois modules / fichiers comme suit :

1.5.2. Structures de données

On va utiliser plusieurs structures de données :

1.5.3. Fonctions à implanter

Pour jeu.h et jeu.cpp:

  1. #pragma once
  2.  
  3. #include <iostream>
  4. #include <iomanip>
  5. using namespace std;
  6.  
  7. const int MAX_JOUEURS = 2;
  8.  
  9. /**
  10.  * Définition d'un type pour les joueurs
  11.  */
  12. typedef enum {
  13.   JOUEUR_1 = 0,
  14.   JOUEUR_2 = 1
  15. } type_joueur;
  16.  
  17. /**
  18.  * Définition d'un type pour la stratégie de déplacement
  19.  * pour l'IA
  20.  */
  21. typedef enum { FUSION = 0,
  22.   ATTAQUE,
  23.   FUITE,
  24.   IA1,
  25.   IA2
  26. } type_strategie;
  27.  
  28. /**
  29.  * Unité de soldats
  30.  */
  31. typedef struct {
  32.   // indique si l'unité est toujours en jeu
  33.   bool valide;
  34.   // identifiant d'unité : 1 à 8 pour joueur 1, 9 à 16 pour joueur 2
  35.   int id;
  36.   // indique à quel joueur appartient l'unité
  37.   type_joueur appartient_a;
  38.   // position sur le plateau de jeu
  39.   int x, y;
  40.   // nombre de soldats
  41.   int soldats;
  42.   // stratégie utilisée par l'IA
  43.   type_strategie strategie;
  44.  
  45. } type_unite;
  46.  
  47. /**
  48.  * Nombre d'unités par joueur
  49.  */
  50. const int MAX_UNITES_PAR_JOUEUR = 8;
  51.  
  52. /**
  53.  * Une armée représente les unités détenues par un joueur
  54.  */
  55. typedef struct {
  56.  
  57.   type_unite unites[ MAX_UNITES_PAR_JOUEUR ];
  58.  
  59. } type_armee;
  60.  
  61.  
  62. const int PLATEAU_MAX_LIGNES = 8;
  63. const int PLATEAU_MAX_COLONNES = 14;
  64.  
  65. #define unite_vide  nullptr
  66.  
  67. /**
  68.  * Type Jeu composé
  69.  * d'un plateau de jeu avec pointeurs sur unités
  70.  * des unités de chaque joueur
  71.  */
  72. typedef struct {
  73.   // Unités pour chaque joueur
  74.   type_armee armees[ MAX_JOUEURS ];
  75.   // Plateau de jeu
  76.   type_unite *plateau[ PLATEAU_MAX_LIGNES ][ PLATEAU_MAX_COLONNES ];
  77.   // joueur qui doit jouer
  78.   type_joueur joueur;
  79.   // tour de jeu
  80.   int tour;
  81.  
  82. } type_jeu;
  83.  
  84.  
  85. void cout_red( string s );
  86. void cout_green( string s );
  87. void cout_blue( string s );
  88.  
  89.  
  90. /**
  91.  * Initialiser le jeu :
  92.  * - créer les armées de chaque joueur et positionner
  93.  * les unités dans chaque camp respectif
  94.  * - mettre le nombre de tour à 1
  95.  * - choisir aléatoirement le joueur qui commencera
  96.  */
  97. void jeu_initialiser( type_jeu& jeu );
  98.  
  99. /**
  100.  * Afficher le plateau de jeu et éventuellement les armées
  101.  * de chaque joueur
  102.  */
  103. void jeu_afficher( type_jeu& jeu );
  104.  
  105. /**
  106.  * Indique si le jeu est terminé, càd :
  107.  * - le nombre de tours est supérieur à 100
  108.  * - ou l'un des joueurs ne peut plus jouer
  109.  */
  110. bool jeu_est_termine( type_jeu& jeu );
  111.  
  112. /**
  113.  * Indique si un déplacement est valide pour le joueur 'joueur'
  114.  * l'unité d'identifiant 'u_id' vers la position (y,x)
  115.  */
  116. bool jeu_deplacement_valide( type_jeu& jeu, int u_id, int y, int x );
  117.  
  118. /**
  119.  * Joue le déplacement pour le joueur 'joueur'
  120.  * l'unité d'identifiant 'u_id' vers la position (y,x)
  121.  */
  122. void jeu_deplacement_jouer( type_jeu& jeu, int u_id, int y, int x );
  123.  
  124.  
  125. void jeu_tour_suivant( type_jeu& jeu );
  126.  
  127.  
  128. typedef enum {
  129.   J1 = 1,
  130.   J2,
  131.   MATCH_NUL,
  132.   AUCUN
  133. } type_gagnant;
  134.  
  135. /**
  136.  * indique si le joueur 1 ou le joueur 2 est gagnant ou si il y a
  137.  * match nul (autant de soldat dans chaque camp, ou si on est dans
  138.  * AUCUN de ces cas de figure
  139.  */
  140. type_gagnant jeu_possede_gagnant( type_jeu& jeu );
  141.  
  142.  
  143.  
  144.  

Pour appli.cpp :

  1. #include <iostream>
  2. using namespace std;
  3.  
  4. #include "jeu.h"
  5.  
  6.  
  7. int main() {
  8.  
  9.   type_jeu jeu;
  10.  
  11.   jeu_initialiser( jeu );
  12.  
  13.  
  14.   while (!jeu_est_termine( jeu )) {
  15.  
  16.     jeu_afficher( jeu );
  17.  
  18.     if (jeu.joueur == JOUEUR_1) {
  19.       cout << "Tour " << jeu.tour << "/100, joueur 1" << endl;
  20.     } else {
  21.         cout << "Tour " << jeu.tour << "/100, joueur 2" << endl;
  22.     }
  23.    
  24.     int u, y, x;
  25.     while (true) {
  26.       cout << "(unite,y,x) ? ";
  27.      
  28.       cin >> u >> y >> x;
  29.       if (jeu_deplacement_valide( jeu, u, y, x)) break;
  30.     }
  31.    
  32.     jeu_deplacement_jouer( jeu, u, y, x);
  33.    
  34.    
  35.     jeu_tour_suivant( jeu );
  36.    
  37.   }
  38.  
  39.   type_gagnant gagnant = jeu_possede_gagnant( jeu );
  40.   string labels[] = { "Joueur 1", "Joueur 2", "Match nul" };
  41.   cout << "gagnant = " << labels[ gagnant ] << endl;
  42.  
  43.  
  44.   return EXIT_SUCCESS;
  45. }
  46.  

Pour ia0.h et ia0.cpp :

  1. #pragma once
  2.  
  3. #include "jeu.h"
  4.  
  5. /**
  6.  * Déplacement d'une unité
  7.  */
  8. typedef struct {
  9.   int x_initial, y_initial;
  10.   int x_final, y_final;
  11.   type_unite *unite;
  12.  
  13. } type_deplacement;
  14.  
  15. /**
  16.  * Intelligence artificielle qui détermine quelle unité déplacer
  17.  * d'une position initiale vers une position finale
  18.  */
  19. void ia( int tour, type_jeu& jeu, type_deplacement& deplacement );
  20.  
  21.  

1.6. Tournoi

1.6.1. Règles

Chaque groupe doit proposer un fichier C qui comporte une fonction qui retourne le prochain coup à jouer.

Chaque groupe affronte un adversaire 10 fois et on comptabilise le nombre de victoires, défaites ou matchs nuls.

Si le code fourni par un groupe :

alors la partie est considérée perdue par ce groupe.

1.6.2. Résultats

 Groupe   Victoires   Défaites   Matchs nuls 
 1   -   -   - 
 2   -   -   - 
 3   -   -   - 
 4   -   -   - 
 5   -   -   - 
Résultats du tournoi