INF3135 Construction et maintenance de logiciels TP2 t 2023

Projet : la bataille navale

nonc

Lobjectif du projet est de dvelopper un jeu de bataille navale. Le joueur saisit tout dabord la taille taille_plateau du plateau de jeu (min 6; max 100). Le programme ensuite place alatoirement 5 navires de taille variant de 2 5 cases sur ce plateau de jeu. Ce sont :

• 1 Porte-avions (5 cases)

• 1 Croiseur (4 cases)

• 2 Contre-torpilleurs (3 cases)

• 1 Torpilleur (2 cases)

(Voir annexe une courte description des navires).

Il est demand ensuite au joueur une case sur laquelle il veut lancer une torpille. Le programme ensuite affiche :

• touch si sur cette case est plac un navire;

• leau si sur cette case nest pas plac un navire;

• dj jou si cette case a dj t joue.

• Une grille de jeu de taille taille_plateau taille_plateau pour laquelle une case est reprsente par le signe

  • x, si la case a t joue et si un navire est plac sur cette case;

  • o, si la case a t joue et si aucun navire nest plac sur cette case;

  • ., si la case na pas t joue.

    Lorsque toutes les cases dun navire ont t touches, un message indique que le navire (en prcisant sa taille et son nom) a t coul. Ce processus est rpt tant quil reste des navires non couls.

    Lorsque tous les navires ont t couls, un message indique que vous avez gagn avec le nombre de coup jous.

    Exemple : Bravo !! Vous avez gagn en 18 coups.

    Statistiques

    Lorsque le logiciel sera invoqu avec l’option -S, il accumulera des statistiques sur les donnes du jeu et crira ces statistiques dans un fichier de sortie spcifi la console.

    Exemple d’excution du logiciel avec l’option -S :

    bash> ./bataille_navale -S stats.txt

    Si le fichier de sortie n’existe pas, il sera cr; s’il existe, il sera cras. Voici les statistiques produire :

• le nombre total de coups ralis pour couler tous les navires;

• le nombre de lettres sans doublon du nom du premier navire touch ;

• le nombre total de coups leau ;

• le nombre total de coups dj jou ;

• le nombre total de coups touch ;

• le nom du dernier navire coul.

Modlisation du problme

1. Structure de donnes

   Une case du jeu est modlise par la structure suivante :

   typedef struct une_case {

   int x; /* position de la case en x*/ int y; /* position de la case en y*/

   } Case;

   Un navire est modlis par la structure suivante :

   typedef struct navire {

   int sens; /* 0 haut 1 droite 2 bas 3 gauche */ Case premiere_case;

   int taille;

   } Navire;

   Le plateau du jeu plateau de taille taille_plateau taille_plateau sur lequel le programme place les navires est allou dynamiquement.

   Le logiciel doit tre dcoup en modules. On devrait, au minimum, retrouver un module pour chaque lment suivant :

   • le main;

   • le jeu (bataille navale);

   • la gestion des statistiques.

   La grille de jeu grille de taille taille_plateau taille_plateau est alloue dynamiquement.

2. Fonctions utiliser

La fonction int nb_aleatoire(int max) qui renvoie un nombre, tir au hasard, compris entre 1 et max.

#include<stdlib.h> #include<time.h>

/* Initialiser le gnrateur au dbut du main par la fonction suivante*/

void init_nb_aleatoire() { srandom(time(NULL));

}

/* Renvoie un nombre, tir au hasard, compris entre 1 et max*/

int nb_aleatoire(int max) { return (random()%max);

}

Voici la liste de quelques prototypes des fonctions utiliser lors de ce projet. Vous avez la libert den crire de nouvelles selon vos besoins.

• Navire creer_navire(int taille, int taille_plateau) : cette fonction permet de crer un navire dune taille

  donne dont la case de dpart et le sens sont fixs alatoirement.

• int est_valide(int **plateau, int taille_plateau, struct navire * nav): cette fonction retourne 1 si le navire est bien situ dans les limites du plateau, et quil ne se chevauche pas avec un autre navire, sinon elle retourne 0.

  • plateau est une matrice reprsentant le plateau de jeu, dans laquelle les cases occupes par des navires contiennent un 1 et les autres un 0.

• void initialisation_plateau(int **plateau, int taille_plateau): cette fonction initialise alatoirement cinq navires de taille 2 5 dans le plateau.

• void proposition_joueur(int **plateau, int **prop, int *nb_touche, int *nb_joue, int

  *nb_touche_nav, int taille_plateau) : cette fonction demande lutilisateur de saisir une case (x,y) jouer et selon la valeur contenue plateau[x][y] enregistre dans prop[x][y] la valeur :

  • 0 si la case ne contient pas de navire

  • -1 si la case a dj t joue

  • 1 si la case contient un navire Note :

  • nb_joue est le compteur du nombre de coups

  • nb_touche est le compteur de cases touches

  • nb_touche_nav est un tableau qui contient le nombre de cases touches pour chaque navire. nb_touche_nav[i] indique le nombre de cases touches pour le navire de taille i.

• void affichage_plateau(int **plateau, int taille_plateau) :

  Amliorations possibles

• criture dune fonction qui affiche diffremment les cases coules et les cases touches.

• Sauvegarde et chargement de parties en cours.

  Exigences du code source

  Vous devez appliquer les exigences suivantes votre code source.

• L’indentation doit tre de 3 espaces. Aucune tabulation n’est permise dans l’indentation.

• Votre code doit tre dcoup en fonctions d’une longueur acceptable. Pas de fonctions de plus de 15 lignes.

• Chaque fonction doit tre documente avec un commentaire expliquant l’objectif de la fonction, les paramtres et la valeur de retour (si applicable). Le nom de la fonction doit tre significatif.

• N’utilisez pas de variables globales (sauf errno).

• Les erreurs systmes doivent tre gres correctement.

• Vous devez adapter une approche de programmation modulaire. Utilisez de fichier den-tte (.h) pour reprsenter vos interfaces et cacher vos implmentations dans les fichiers (.c). Vos modules devraient suivre le standard vu en classe.

• Les identifiants de fonctions et variables doivent tre en snake_case.

• Une attention particulire doit tre apporte la lisibilit du code source.

• Vous devrez utiliser bats et Cunit (80% de couverture et code de test propre) comme cadres de test pour tester votre logiciel

• Vous devez adopter une approche de dveloppement par branche et initier des merge request pour toutes vos fusions dans la branche principale. Plus spcifiquement, tout module, documentation et correctifs doivent faire lobjet dune nouvelle branche.

• Vous devez ajouter une intgration continue (IC) de votre projet. LIC doit tre constitue dau moins 2 tches : une tche de construction et de test.

• Vous devez fournir un Makefile qui exprime les dpendances de faon complte.

  Exigences techniques (Pnalit 20%)

• Votre travail doit tre rdig en langage C et doit compiler sans erreur et sans avertissement sur le serveur Java de lUQAM (java.labunix.uqam.ca). Pour vous y connecter, vous devez connatre votre CodeMS (de la forme ab123456) ainsi que votre mot de passe (de la forme ABC12345)

• Votre dpt doit se nommer exactement inf3135-ete2023-tp2

• L’URL de votre dpt doit tre exactement

  https://gitlab.info.uqam.ca/<utilisateur>/inf3135-ete2023-tp2 o

  <utilisateur> doit tre remplac par votre identifiant

• Votre dpt doit tre priv

• Les usagers @lapointe.gabriel.2 et dogny_g doivent avoir accs votre projet comme

  Developer

  Remise

  Le travail est automatiquement remis la date de remise prvue. Vous n’avez rien de plus faire. Assurez-vous davoir votre travail disponible sur votre branche main qui sera considre pour la correction. Tous les commits aprs le 9 juillet 2023 23:55 ne seront pas considrs pour la correction.

  Barme

  Critre		Points
  Fonctionnalit		/30
  Amliorations possibles		/10
  Qualit du code		/10
  Utilisation de git		/10
  Tests	Cunit	/10
  	Bats	/10
  GitLab-CI		/10
  Makefile		/5
  Documentation		/5
  Total		/100

  Plus prcisment, les lments suivants seront pris en compte:

• Fonctionnalit (30 points): Tous les programmes compilent et affichent les rsultats attendus.

• Amliorations possibles (10 points): Implmentation des amliorations suggres dans lnonc.

• Qualit du code (10 points): Les identifiants utiliss sont significatifs et ont une syntaxe uniforme, le code est bien indent, il y a de l’aration autour des oprateurs et des parenthses, le programme est simple et lisible. Pas de bout de code en commentaire ou de commentaires inutiles. Pas de valeur magique. Le code doit tre bien factoris (pas de redondance) et les erreurs bien gres. La prsentation doit tre soigne.

• Documentation (5 points): Le fichier README.md est complet et respecte le format Markdown. Il explique comment compiler et excuter vos programmes ainsi que toutes les autres cibles demandes.

• Utilisation de Git (10 points): Les modifications sont rparties en commits atomiques. Le fichier

  .gitignore est complet. Utilisation des branches. Les messages de commit sont significatifs et uniformes. Les demandes dintgration.

• Tests (20 points): Le code de test est propre, avec une couverture de 80%. Cunit et Bats.

• Makefile (5 points): Le Makefile doit supporter au moins les cibles compile, link, test et une cible html permettant de crer une version html du README.md. Lappel make doit compiler et construire lexcutable.

• GitLab-CI (10 points): Votre projet doit supporter le systme dintgration continue de GitLab (GitLab- CI) qui construit et roule tous vos tests chaque commit sur la branche master.

SOVLEDc_tp2