Changeset ,27

Timestamp:

05/23/08 08:21:08 (8 months ago)

Author:

Florian Birée <florian@…>

branch-nick:

code

Message:

Correction de bugs dans le placement des bateaux

Files:

• Makefile (modified) (1 diff)
• src/ia/ia.c (modified) (6 diffs)
• src/ocean/ocean.c (modified) (5 diffs)
• src/ocean/test.c (modified) (4 diffs)
• src/texte/texte.c (modified) (4 diffs)
• src/texte/texte.h (modified) (4 diffs)

Makefile

@@ -1 +1 @@
 CC=gcc
-CFLAGS=-W -Wall -ansi -pedantic
+CFLAGS=-W -Wall -ansi -pedantic -g
 LDFLAGS=
 EXEC=batnav
-OBJ=src/tableau.o src/sudoku.o src/main.o
+OBJ=src/ocean/ocean.o src/ia/ia.o src/texte/texte.o
 
 util: $(OBJ)
         $(CC) $(OBJ) -o $(EXEC)
 
-src/tableau.o: src/tableau.c
-src/sudoku.o: src/sudoku.c
-src/main.o: src/main.c
+src/ocean/ocean.o: src/ocean/ocean.h
+src/ia/ia.o: src/ia/ia.h src/ocean/ocean.c
+src/texte/texte.o: src/texte/texte.h src/ia/ia.c src/ocean/ocean.c
 
 install:
         cp $(EXEC) /usr/bin/
         cp man/batnav.1.gz /usr/share/man/man1
-        mkdir -p /usr/share/doc/sudoku
+        mkdir -p /usr/share/doc/batnav
         cp AUTHORS CHANGELOG COPYING INSTALL README /usr/share/doc/batnav
 

src/ia/ia.c

@@ -6 +6 @@
  * Raison de la derniÚre modification : ajout de ia_jouer
  */
+
+#include <stdio.h>
 
 #include <stdlib.h>
@@ -204 +206 @@
         int decalage;
         bool tir_trouve = false;
+        printf("%s - mode difficile\n", joueur->nickname);
         /* Recherche de la case où effectuer le tir */
         do
@@ -335 +338 @@
                         ia_decalage_x(x, -1, contexte->orientation),
                         ia_decalage_y(y, -1, contexte->orientation),
-                        TOUCHE))
+                        INCONNUE))
             {
                 /* La choisir */
@@ -347 +350 @@
                         ia_decalage_x(x, 1, contexte->orientation),
                         ia_decalage_y(y, 1, contexte->orientation),
-                        TOUCHE))
+                        INCONNUE))
             {
                 /* La choisir */
@@ -357 +360 @@
             else
             {
+                printf("%s - changement d'orientation de recherche.\n",
+                        joueur->nickname);
                 /* Changer d'orientation */
-                contexte->orientation = ! contexte-> orientation;
+                contexte->orientation = ! (contexte-> orientation);
                 /* Recommencer */
             }
@@ -372 +377 @@
             contexte->bateau_trouve = false;
         }
-        /* Sinon : */
-        else
+        /* Sinon, si la case est touchée : */
+        else if (ocean_statut_ennemi(*plateau, *joueur, tir_x, tir_y) == TOUCHE)
         {
             /* mettre bateau_x et bateau_y à la position du tir */

src/ocean/ocean.c

@@ -6 +6 @@
  * Raison de la derniÚre modification : ajout des fonctions de statut
  */
+
+#include <stdio.h>
 
 #include <stdlib.h>
@@ -116 +118 @@
     
     /* Si le bateau sur toute sa longueur ne sort pas de la grille : */
-    if (((orientation == VERTICAL) && (y + categorie >= TAILLE_GRILLE)) ||
-        ((orientation == HORIZONTAL) && (x + categorie >= TAILLE_GRILLE)))
+    if (((orientation == VERTICAL) && (y + categorie > TAILLE_GRILLE)) ||
+        ((orientation == HORIZONTAL) && (x + categorie > TAILLE_GRILLE)))
     {
         return false;
@@ -137 +139 @@
         for(i=y; i<y+categorie; i++)
         {
-            if (!ocean_case_est_libre(*plateau, joueur, i, y))
+            if (!ocean_case_est_libre(*plateau, joueur, x, i))
             {
                 return false;
@@ -147 +149 @@
     ocean_initialiser_bateau (&bateau);
     bateau->categorie = categorie;
+    bateau->orientation = orientation;
     /* L'ajouter à la liste des bateaux */
     plateau->liste_bateaux[joueur.id][plateau->nombre_bateaux[joueur.id]] = \
@@ -232 +235 @@
     ocean_T_Bateau* bateau;
     
-    for (i=x-1; i<=x+1; i++)
-    {
-        for (j=y-1; j<=y+1; j++)
+    for (i=x-1; i<x+2; i++)
+    {
+        for (j=y-1; j<y+2; j++)
         {
             /*si la case est dans le plateau*/
-            if ((i<TAILLE_GRILLE) && (j<TAILLE_GRILLE) && (i>0) && (j>0))
+            if ((i<TAILLE_GRILLE) && (j<TAILLE_GRILLE) && (i>=0) && (j>=0))
             {
                 /*on verifie qu'elle est libre*/

src/ocean/test.c

@@ -76 +76 @@
     /* Test d'une case non libre */
     ocean_initialiser_bateau(&bateau);
-    plateau.grille[0][5][5].bateau = bateau;
-    CU_ASSERT(ocean_case_est_libre(plateau, joueur0, 5, 5) == false);
+    bateau->categorie = PORTE_AVION;
+    bateau->orientation = HORIZONTAL;
+    (plateau.grille[0][0][0]).bateau = bateau;
+    (plateau.grille[0][1][0]).bateau = bateau;
+    (plateau.grille[0][2][0]).bateau = bateau;
+    (plateau.grille[0][3][0]).bateau = bateau;
+    CU_ASSERT(ocean_case_est_libre(plateau, joueur0, 0, 0) == false);
     /* Test d'une case avec une voisine non libre */
-    CU_ASSERT(ocean_case_est_libre(plateau, joueur0, 4, 5) == false);
+    CU_ASSERT(ocean_case_est_libre(plateau, joueur0, 0, 1) == false);
+    /* Test du bug :
+     * Destroyer en c3 v
+     * Destroyer en d4 v -> devrait être impossible */
+    ocean_initialiser_joueur(&joueur0, 0, "J0", JOUEUR_LOCAL, NULL);
+    ocean_initialiser_joueur(&joueur1, 1, "J1", JOUEUR_LOCAL, NULL);
+    ocean_initialiser_plateau(&plateau, &joueur0, &joueur1);
+    ocean_initialiser_bateau(&bateau);
+    bateau->categorie = DESTROYER;
+    bateau->orientation = VERTICAL;
+    (plateau.grille[0][2][3]).bateau = bateau;
+    (plateau.grille[0][2][4]).bateau = bateau;
+    (plateau.grille[0][2][5]).bateau = bateau;
+    CU_ASSERT(ocean_case_est_libre(plateau, joueur0, 3, 4) == false);
 }
 
@@ -118 +136 @@
                                   PORTE_AVION) == false);
     /* Test de placer un bateau à un emplacement valide */
-    CU_ASSERT(ocean_placer_bateau(&plateau, joueur0, 1, 1, HORIZONTAL,
+    CU_ASSERT(ocean_placer_bateau(&plateau, joueur0, 0, 0, HORIZONTAL,
                                   PORTE_AVION) == true);
-    ocean_statut(plateau, joueur0, 1, 1, &bateau);
+    ocean_statut(plateau, joueur0, 0, 0, &bateau);
     CU_ASSERT(bateau != NULL);
     CU_ASSERT(bateau->categorie == PORTE_AVION);
@@ -127 +145 @@
                                   CROISEUR) == false);
     /* Test de placer un bateau à proximité d'un autre */
-    CU_ASSERT(ocean_placer_bateau(&plateau, joueur0, 4, 2, VERTICAL,
+    CU_ASSERT(ocean_placer_bateau(&plateau, joueur0, 0, 1, VERTICAL,
                                   CROISEUR) == false);
+    /* Test du bug :
+     * Porte-avion en d0 h
+     * Destroyer en c3 v
+     * Destroyer en d4 v -> devrait être impossible */
+    ocean_initialiser_joueur(&joueur0, 0, "J0", JOUEUR_LOCAL, NULL);
+    ocean_initialiser_joueur(&joueur1, 1, "J1", JOUEUR_LOCAL, NULL);
+    ocean_initialiser_plateau(&plateau, &joueur0, &joueur1);
+    /* Test de placer un bateau hors de la grille */
+    CU_ASSERT(ocean_placer_bateau(&plateau, joueur0, 3, 0, HORIZONTAL,
+                                  PORTE_AVION) == true);
+    CU_ASSERT(ocean_placer_bateau(&plateau, joueur0, 2, 3, VERTICAL,
+                                  DESTROYER) == true);
+    CU_ASSERT(ocean_placer_bateau(&plateau, joueur0, 3, 4, VERTICAL,
+                                  DESTROYER) == false);
 }
 
@@ -290 +322 @@
     ocean_initialiser_plateau(&plateau, &joueur0, &joueur1);
     /* Tester le statut d'une case vide non tirée */
-    CU_ASSERT(ocean_statut(plateau, joueur0, 0, 0, &bateau) == INCONNUE);
+    CU_ASSERT(ocean_statut(plateau, joueur0, 9, 9, &bateau) == INCONNUE);
     CU_ASSERT(bateau == NULL);
     /* Tirer sur une case */
-    ocean_tir(&plateau, &joueur1, 0, 0);
+    ocean_tir(&plateau, &joueur1, 9, 9);
     /* Tester le statut de la case vide tirée */
-    CU_ASSERT(ocean_statut(plateau, joueur0, 0, 0, &bateau) == DANS_LEAU);
+    CU_ASSERT(ocean_statut(plateau, joueur0, 9, 9, &bateau) == DANS_LEAU);
     CU_ASSERT(bateau == NULL);
     /* Placer un bateau */
-    ocean_placer_bateau(&plateau, joueur0, 1, 1, VERTICAL, DESTROYER);
+    ocean_placer_bateau(&plateau, joueur0, 2, 2, VERTICAL, DESTROYER);
     /* Tester le statut d'une case du bateau*/
-    CU_ASSERT(ocean_statut(plateau, joueur0, 1, 1, &bateau) == INCONNUE);
+    CU_ASSERT(ocean_statut(plateau, joueur0, 2, 2, &bateau) == INCONNUE);
     CU_ASSERT(bateau != NULL);
     /* Tirer sur le bateau */
-    ocean_tir(&plateau, &joueur1, 1, 1);
+    ocean_tir(&plateau, &joueur1, 2, 2);
     /* Tester le statut d'une case du bateau touchée */
-    CU_ASSERT(ocean_statut(plateau, joueur0, 1, 1, &bateau) == TOUCHE);
+    CU_ASSERT(ocean_statut(plateau, joueur0, 2, 2, &bateau) == TOUCHE);
     CU_ASSERT(bateau != NULL);
     /* Couler le bateau */
-    ocean_tir(&plateau, &joueur1, 1, 2);
+    ocean_tir(&plateau, &joueur1, 2, 3);
     /* Tester le statut d'une case du bateau coulé */
-    CU_ASSERT(ocean_statut(plateau, joueur0, 1, 2, &bateau) == COULE);
+    CU_ASSERT(ocean_statut(plateau, joueur0, 2, 3, &bateau) == COULE);
+    /* Test du statut pour un port-avion horizontal en 0,0 */
+    ocean_initialiser_bateau(&bateau);
+    bateau->categorie = PORTE_AVION;
+    bateau->orientation = HORIZONTAL;
+    (plateau.grille[0][0][0]).bateau = bateau;
+    (plateau.grille[0][1][0]).bateau = bateau;
+    (plateau.grille[0][2][0]).bateau = bateau;
+    (plateau.grille[0][3][0]).bateau = bateau;
+    CU_ASSERT(ocean_statut(plateau, joueur0, 0, 0, &bateau) == INCONNUE);
+    CU_ASSERT(bateau != NULL);
 }
 

src/texte/texte.c

@@ -9 +9 @@
 #include <string.h>
 #include <stdlib.h>
+#include <time.h>
 
 #include "../ocean/ocean.h"
+#include "../ia/ia.h"
 #include "texte.h"
-#include "../ia/ia.h"
-
-
-
-
-/* Nom de la fonction : void texte_initialiser_joueur_local(ocean_T_joueur *joueur)
+
+/* Nom de la fonction : void texte_initialiser_joueur_local
  * Initialise le joueur local
  * ParamÚtre : ocean_T_joueur *joueur
@@ -24 +22 @@
 void texte_initialiser_joueur_local(ocean_T_Joueur* joueur)
 {
-        int id=2;
-        char nom[NB_MAX_LETTRES_NOM+1];
-        int categorie=JOUEUR_LOCAL;
-        printf("Veuillez entrer votre nom :");
-        scanf("%s", nom);
-        strcpy(joueur->nickname, nom);
-        while (id != 1 || id !=0)
-        {
-                printf("Voulez vous jouer en premier? 0 pour oui, 1 pour non\n");
-                scanf("%1d", &id);
-        }
-        ocean_initialiser_joueur(joueur, id, nom, categorie, NULL);
-}
-
-
-/* Nom de la fonction : void texte_remplir_tableau_bataille_navale (ocean_T_Plateau plateau, ocean_T_Joueur joueur, char tableau[80][25])
- * rempli un tableau avec le plateau du joueur et ceui du joueur ennemi
+    int id=2;
+    char nom[NB_MAX_LETTRES_NOM+1];
+    int categorie=JOUEUR_LOCAL;
+    printf("Veuillez entrer votre nom :");
+    scanf("%s", nom);
+    strcpy(joueur->nickname, nom);
+    while (id != 1 && id !=0)
+    {
+        printf("Voulez vous jouer en premier ?\n");
+        printf("0 : oui\n");
+        printf("1 : non\n");
+        scanf("%1d", &id);
+    }
+    ocean_initialiser_joueur(joueur, id, nom, categorie, NULL);
+}
+
+/*** Fonctions d'affichage ***/
+
+/* Nom de la fonction : void texte_initialiser_affichage
+ * Initialise le tableau d'affichage
+ * ParamÚtre : char affichage[AFF_LONG][AFF_HAUT]
+ * RÎle du paramÚtre : tableau d'affichage à initialiser
+ */
+void texte_initialiser_affichage(char affichage[AFF_LONG][AFF_HAUT])
+{
+    int i, j;
+    
+    /* Initialiser le tableau à vide */
+    for(i = 0; i < AFF_LONG; i++)
+    {
+        for(j = 0; j < AFF_HAUT; j++)
+        {
+            affichage[i][j] = ' ';
+        }
+    }
+    
+    /* Définir les en-têtes des grilles */
+    
+    /* grille de gauche, ligne d'en haut */
+    j=DEPART_LIGNE_J - 1;
+    for(i=DEPART_COLONNE_J; i<DEPART_COLONNE_J+TAILLE_GRILLE; i++)
+    {
+        affichage[i][j]=(char)((int)'a'+(i - DEPART_COLONNE_J));
+    }
+    /*tableau de droite, ligne d'en haut*/
+    for(i=DEPART_COLONNE_J_ENNEMI; i<DEPART_COLONNE_J_ENNEMI+TAILLE_GRILLE; i++)
+    {
+        affichage[i][j]=(char)((int)'a'+(i - DEPART_COLONNE_J_ENNEMI));
+    }
+    
+    i=DEPART_COLONNE_J-1;
+    /*tableau de gauche, colonne de gauche*/
+    for(j=DEPART_LIGNE_J ;j<DEPART_LIGNE_J+TAILLE_GRILLE ;j++)
+    {
+        affichage[i][j]=(char)((int)'0'+(j-DEPART_LIGNE_J));
+    }
+    
+    i=DEPART_COLONNE_J_ENNEMI-1;
+    /*tableau de droite, colonne de gauche*/
+    for(j=DEPART_LIGNE_J_ENNEMI ;j<DEPART_LIGNE_J_ENNEMI+TAILLE_GRILLE ;j++)
+    {
+        affichage[i][j]=(char)((int)'0'+(j - DEPART_LIGNE_J_ENNEMI));
+    }
+}
+
+/* Nom de la fonction : void texte_afficher_plateau
+ * Actualise et affiche le plateau
  * ParamÚtre : ocean_T_Plateau plateau
- * RÎle du paramÚtre : plateau du joueur
+ * RÎle du paramÚtre : plateau à afficher
  * ParamÚtre : ocean_T_Joueur joueur
- * RÎle du paramÚtre : plateau du joueur a afficher
- * ParamÚtre : char tableau[80][25]
- * RÎle du paramÚtre : tableau à remplir
- */
-void texte_remplir_tableau_bataille_navale (ocean_T_Plateau plateau, ocean_T_Joueur joueur, char tableau[80][25])
-{       
-        int x, y;
-        ocean_T_Etat etat;
-        ocean_T_Etat etat_ennemi;
-        ocean_T_Bateau* bateau;
-        
-        for (x=0; x<TAILLE_GRILLE; x++)
-        {
-                for(y=0; y<TAILLE_GRILLE; y++)
-                {
-                        etat = ocean_statut(plateau, joueur, x, y, &bateau);
-                        if      (etat==TOUCHE)
-                        {
-                                tableau[x+DEPART_LIGNE_J][y+DEPART_COLONNE_J]='x';
-                        }
-                        if      (etat==INCONNUE)
-                        {
-                                tableau[x+DEPART_LIGNE_J][y+DEPART_COLONNE_J]='.';
-                        }
-                        if      (etat==COULE)
-                        {
-                                tableau[x+DEPART_LIGNE_J][y+DEPART_COLONNE_J]='#';
-                        }
-                        if      (etat==DANS_LEAU)
-                        {
-                                tableau[x+DEPART_LIGNE_J][y+DEPART_COLONNE_J]='o';
-                        }
-                        if      (bateau != NULL)
-                        {
-                                tableau[x+DEPART_LIGNE_J][y+DEPART_COLONNE_J]='X';
-                        }
-                }       
-        }
-        
-        for (x=0; x<TAILLE_GRILLE; x++)
-        {
-                for(y=0; y<TAILLE_GRILLE; y++)
-                {
-                        etat_ennemi=ocean_statut_ennemi(plateau, joueur, x, y);
-                        if      (etat==TOUCHE)
-                        {
-                                tableau[x+DEPART_LIGNE_J_ENNEMI][y+DEPART_COLONNE_J_ENNEMI]='x';
-                        }
-                        if      (etat==INCONNUE)
-                        {
-                                tableau[x+DEPART_LIGNE_J_ENNEMI][y+DEPART_COLONNE_J_ENNEMI]='.';
-                        }
-                        if      (etat==COULE)
-                        {
-                                tableau[x+DEPART_LIGNE_J_ENNEMI][y+DEPART_COLONNE_J_ENNEMI]='#';
-                        }
-                        if      (etat==DANS_LEAU)
-                        {
-                                tableau[x+DEPART_LIGNE_J_ENNEMI][y+DEPART_COLONNE_J_ENNEMI]='o';
-                        }
-                        
-                }       
-        }
-}
-
-
-/* Nom de la fonction : void texte_afficher_plateau (tableau[80][25])
- * Affiche le plateau et le plateau ennemi
- * ParamÚtre : char tableau[80][25]
- * RÎle du paramÚtre : tableau à afficher
- */
-void texte_afficher_plateau (char tableau[80][25])
-{
-        int i, j;
-        for (i=0; i<80; i++)
-        {
-                for (j=0; j<25; j++)
-                {
-                        printf("%c", tableau[i][j]);
-                }               
-                printf("\n");
-        }
-}
-
-/* Nom de la fonction : void texte_placer_local(ocean_T_Plateau *plateau, ocean_T_Joueur joueur)
+ * RÎle du paramÚtre : joueur dont on veut afficher le jeu
+ * ParamÚtre : char affichage[AFF_LONG][AFF_HAUT]
+ * RÎle du paramÚtre : tableau d'affichage
+ */
+void texte_afficher_plateau (ocean_T_Plateau plateau, ocean_T_Joueur joueur,
+                             char affichage[AFF_LONG][AFF_HAUT])
+{   
+    int x, y;
+    ocean_T_Etat etat;
+    ocean_T_Bateau* bateau;
+    
+    /* Actualiser l'affichage */
+    
+    for (x=0; x<TAILLE_GRILLE; x++)
+    {
+        for(y=0; y<TAILLE_GRILLE; y++)
+        {
+            etat = ocean_statut(plateau, joueur, x, y, &bateau);
+            if  (etat==TOUCHE)
+            {
+                affichage[x+DEPART_COLONNE_J][y+DEPART_LIGNE_J]='x';
+            }
+            else if  (etat==COULE)
+            {
+                affichage[x+DEPART_COLONNE_J][y+DEPART_LIGNE_J]='#';
+            }
+            else if  (etat==DANS_LEAU)
+            {
+                affichage[x+DEPART_COLONNE_J][y+DEPART_LIGNE_J]='o';
+            }
+            else if (bateau != NULL)
+            {
+                affichage[x+DEPART_COLONNE_J][y+DEPART_LIGNE_J]='X';
+            }
+            else
+            {
+                affichage[x+DEPART_COLONNE_J][y+DEPART_LIGNE_J]='.';
+            }
+        }   
+    }
+    
+    for (x=0; x<TAILLE_GRILLE; x++)
+    {
+        for(y=0; y<TAILLE_GRILLE; y++)
+        {
+            etat=ocean_statut_ennemi(plateau, joueur, x, y);
+            if  (etat==TOUCHE)
+            {
+                affichage[x+DEPART_COLONNE_J_ENNEMI][y+DEPART_LIGNE_J_ENNEMI]='x';
+            }
+            else if  (etat==COULE)
+            {
+                affichage[x+DEPART_COLONNE_J_ENNEMI][y+DEPART_LIGNE_J_ENNEMI]='#';
+            }
+            else if  (etat==DANS_LEAU)
+            {
+                affichage[x+DEPART_COLONNE_J_ENNEMI][y+DEPART_LIGNE_J_ENNEMI]='o';
+            }
+            else
+            {
+                affichage[x+DEPART_COLONNE_J_ENNEMI][y+DEPART_LIGNE_J_ENNEMI]='.';
+            }
+        }
+    }
+    
+    /* Afficher */
+    
+    for (y=0; y<AFF_HAUT; y++)
+    {
+        for (x=0; x<AFF_LONG; x++)
+        {
+            printf("%c", affichage[x][y]);
+        }
+        printf("\n");
+    }
+    
+    /* Afficher les scores */
+    printf("Scores : %d\t\t\t%d\n", joueur.score, \
+            plateau.joueur[ocean_id_ennemi(joueur)]->score);
+}
+
+/*** Fonctions de jeu ***/
+/* Nom de la fonction : void texte_placer_local
  * Place les bateaux sur la grille
  * ParamÚtre : Plateau *plateau
@@ -134 +180 @@
  * ParamÚtre : Joueur joueur
  * RÎle du paramÚtre : joueur qui place les bateaux
- */
-void texte_placer_local(ocean_T_Plateau *plateau, ocean_T_Joueur joueur)
+ * ParamÚtre : char affichage[AFF_LONG][AFF_HAUT]
+ * RÎle du paramÚtre : tableau d'affichage
+ */
+void texte_placer_local(ocean_T_Plateau *plateau, ocean_T_Joueur joueur, 
+                        char affichage[AFF_LONG][AFF_HAUT])
 {
-        int x, y;
-        char a;
-        int b;
-        ocean_T_BateauCategorie liste_categories[NB_CATEGORIES_BATEAUX] = CATEGORIES_BATEAUX;
-        ocean_T_BateauCategorie categorie_en_cours;
-        int i, j;
-        int nombre;
-        int orientation;
-        
-        for(i=0; i<NB_CATEGORIES_BATEAUX; i++)
-        {
-                categorie_en_cours = liste_categories[i];
-                /* Tu peux ensuite utiliser la categorie de bateau ma_categorie */
-                /* Si tu veux savoir le nombre de bateaux à placer dans cette catégorie : */
-                nombre = ocean_nb_bateau(categorie_en_cours);
-                for (j=0; j<nombre; j++)
-                {
-                        texte_afficher_plateau (tableau);
-                        printf("Placez ");
-                        if (categorie_en_cours==PORTE_AVION)
-                        {
-                                printf ("le porte avion numéro ");
-                        }
-                        if (categorie_en_cours==CROISEUR)
-                        {
-                                printf ("le croiseur numéro  ");
-                        }
-                        if (categorie_en_cours==DESTROYER)
-                        {
-                                printf ("le destroyez numéro  ");
-                        }
-                        if (categorie_en_cours==VEDETTE)
-                        {
-                                printf ("la vedette numéro ");
-                        }
-                        printf("%d : coordonnées et orientation : 0 pour horizontal ou 1 vertical\n", j);
-                        do
-                        {
-                                printf("Attention, il faut entrer des coordonnées valides.\n");
-                                scanf("%c %d", &a, &b);
-                                x=(int)a - (int)'a';
-                                y=b-1;
-                                scanf("%d", &orientation);
-                                
-                        }while (! ocean_placer(plateau, joueur, x, y, orientation, categorie_en_cours));
-                }
-        } 
-}
-
-void texte_embellir_plateau(char tableau[80][25])
-{
-        int i, j;
-        
-        /*tableau de gauche, ligne d'en haut*/
-        i=DEPART_LIGNE_J -1;
-        for(j=DEPART_COLONNE_J; j<DEPART_COLONNE_J+TAILLE_GRILLE; j++)
-        {
-                tableau[i][j]=(char)((int)'A'+j);
-        }
-        /*tableau de droite, ligne d'en haut*/
-        for(j=DEPART_COLONNE_J_ENNEMI; j<DEPART_COLONNE_J_ENNEMI+TAILLE_GRILLE; j++)
-        {
-                tableau[i][j]=(char)((int)'A'+j);
-        }
-        
-        j=DEPART_COLONNE_J-1;
-        /*tableau de gauche, colonne de gauche*/
-        for(i=DEPART_LIGNE_J ;i<DEPART_LIGNE_J+TAILLE_GRILLE ;i++)
-        {
-                tableau[i][j]=(char)((int)'0'+i);
-        }
-        
-        j=DEPART_COLONNE_J_ENNEMI-1;
-        /*tableau de droite, colonne de gauche*/
-        for(i=DEPART_LIGNE_J_ENNEMI ;i<DEPART_LIGNE_J_ENNEMI+TAILLE_GRILLE ;i++)
-        {
-                tableau[i][j]=(char)((int)'0'+i);
-        }
-}
-
-
-/* Nom de la fonction : void texte_placer_local(ocean_T_Plateau *plateau, ocean_T_Joueur joueur)
+    ocean_T_BateauCategorie liste_categories[NB_CATEGORIES_BATEAUX] = \
+                                                        CATEGORIES_BATEAUX ;
+    int i;
+    /* Pour chaque categorie de bateau : */
+    for(i = 0; i < NB_CATEGORIES_BATEAUX; i++)
+    {
+        ocean_T_BateauCategorie categorie = liste_categories[i];
+        int nombre_bateaux = ocean_nb_bateau(categorie), j;
+        /* Pour le nombre de bateau à placer dans cette catégorie : */
+        for(j = 0; j < nombre_bateaux; j++)
+        {
+            int x, y;
+            bool orientation;
+            /* Tant que le bateau n'est pas placé : */
+            do
+            {
+                char a;
+                int choix_orientation;
+                /* Afficher la grille */
+                texte_afficher_plateau(*plateau, joueur, affichage);
+                /* Choix d'une position dans la grille : */
+                printf("Placez ");
+                if (categorie==PORTE_AVION)
+                {
+                    printf ("le porte avion numéro ");
+                }
+                if (