Bonjour à tous,
Je travaille sur un projet qui est le jeu de la bataille navale et j'ai un petit probleme de fonctions... je vais vous expliquer. J'ai une fonction qui permet de placer les navires manuellement elle marche trés bien quand je l'execute toute seul, mais des que je la fais preceder de ma fonction pour le menu ma fonction placerNavire ne reconnais pas les données que je saisit, c'est bizarre !

Voici mon programme :
(Si vous voyez des erreurs merci de me les signaler je ne suis pas un pro du C, merci d'avance)

                /* DIRECTIVE D'INCLUSION */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#define MAX 10
#define tailleCase 3
#define tailleTab 11

/* Structure coordonnees qui fait reference a une case des grilles ************/
typedef struct
{
    int x;
    int y;
} coord;
/******************************************************************************/

/* Structure navire qui repertorie les parametre des differents navires *******/
typedef struct
{
    char nom[3];
    int taille;
    coord tab[MAX];
} navire;
/******************************************************************************/

/* Structure joueur qui repertorie les parametre du joueur ********************/
typedef struct
{
    char nomJ[20];
    char grille_jeu[tailleTab][tailleTab][tailleCase];
    char grille_tire[tailleTab][tailleTab][tailleCase];
} joueur;
/******************************************************************************/

/* Structure qui gere les parametre de la partie ******************************/
typedef struct
{
    int mode_jeu;
    int mode_placement;
    int difficulte_jeu;
} paramPartie;
/******************************************************************************/   
   
/* Variables Statiques ********************************************************/
navire sousMarins;
navire fregate;
navire destroyer;
navire porteAvion;
int nbNavire=6;
paramPartie paramJoueur1;
paramPartie paramJoueur2;
navire tab[MAX];
/******************************************************************************/


/* Fonction qui transforme un chaine en majuscule *****************************/
void upper(char s[])
{
  int index;
 
  for (index= 0; s[index] != '\0'; index++)
    if (s[index] >= 'a' && s[index] <= 'z')
      s[index]= s[index] - 'a' + 'A';
}
/******************************************************************************/

/* Fonction qui initialise les grilles (jeu et tire) d'un joueur **************/
joueur initTabJoueur()
{
joueur joueur;
int i;
int j;
char tab1[10][3]={"A ","B ","C ","D ","E ","F ","G ","H ","I ","J "};
char tab2[10][3]={"0 ","1 ","2 ","3 ","4 ","5 ","6 ","7 ","8 ","9 "};

strcpy( joueur.grille_jeu[0][0], "  ");

j=0;
for(i=1; i<11; i++)
{
    strcpy( joueur.grille_jeu[i][j], tab1[i-1]);
}

i=0;
for(j=1; j<11; j++)
{
    strcpy( joueur.grille_jeu[i][j], tab2[j-1]);
}
    
for(i=1; i<11; i++)
{
    for(j=1; j<11; j++)
    {
strcpy( joueur.grille_jeu[i][j], "~~");
    }
}

for(i=0; i<11; i++)
{
    for(j=0; j<11; j++)
    {
    strcpy( joueur.grille_tire[i][j], joueur.grille_jeu[i][j]);
    }
}

return(joueur);
}
/******************************************************************************/

/* Procedure qui affiche les grilles de jeu et de tire ************************/
void afficheTabJoueur(joueur joueur)
{
int i;
int j;

printf("\nVotre grille de jeu : \n\n");
for(i=0; i<11; i++)
{
    for(j=0; j<11; j++)
    {
    printf("%s  ", joueur.grille_jeu[i][j]);
    }
printf("\n");
}

printf("\n");
printf("\nVotre grille de tire : \n\n");
for(i=0; i<11; i++)
{
    for(j=0; j<11; j++)
    {
    printf("%s  ", joueur.grille_tire[i][j]);
    }
printf("\n");
}
}
/******************************************************************************/

/* Fonction qui verifie les coordonnees lorsqu'on place les bateaux ***********/
int verif_coordonnees( joueur joueur, char choix, navire type)
{
char tabintermediaire[12][12][3];
int i;
int j;
int compteur=0;
int x;
int y;

for(i=0; i<12; i++)
{
    for(j=0; j<12; j++)
    {
    strcpy(tabintermediaire[i][j], "~~");
    }
}

for(i=1; i<11; i++)
{
    for(j=1; j<11; j++)
    {
    strcpy(tabintermediaire[i][j], joueur.grille_jeu[i][j]);
    }
}

x=type.tab->x+1;
y=type.tab->y+1;

if(choix=='h' && type.tab->y<=10-type.taille)
{
    for(i=x-1; i<=x+1; i++)
    {
       for(j=y-1; j<=y+type.taille; j++)
       {
            if(strcmp(tabintermediaire[i][j], "~~")==0)
            {
            compteur++;
            }
        }
    }
}

if(choix=='v' && type.tab->x<=10-type.taille)
{
    for(i=x-1; i<=x+type.taille; i++)
    {
       for(j=y-1; j<=y+1; j++)

       {
            if(strcmp(tabintermediaire[i][j], "~~")==0)
            {
            compteur++;
            }
        }
    }
}

if(compteur==(type.taille+2)*3)
{
    return(1);
}
else
{
    printf("Veuillez saisir des coordonnees valables !!!\n");
    return(0);
}
}
/******************************************************************************/

/* Procedure qui permet de placer les bateaux manuellement ********************/
void placerNavireManu(joueur* joueur)
{
char choix_sens;
int i;
int j;
int k;
int l;
char x;

for(j=nbNavire-1; j>=0; j--)
{

    printf("Dans quelle sens souhaitez-vous placer votre %s (h/v) : ", tab[j].nom);
    scanf("%c", &choix_sens);
    getchar();

    do
    {   
    printf("Saisissez les coordonnees de la premiere case de votre %s : ", tab[j].nom);
    scanf("%c%d", &x, &tab[j].tab->y);
    getchar();

    printf("\n");

    switch(x)
    {
        case 'A':
    case'a': tab[j].tab->x=0;break;
        case 'B':
    case'b': tab[j].tab->x=1;break;
        case 'C':
    case'c': tab[j].tab->x=2;break;
        case 'D':
    case'd': tab[j].tab->x=3;break;
        case 'E':
    case'e': tab[j].tab->x=4;break;
        case 'F':
    case'f': tab[j].tab->x=5;break;
        case 'G':
    case'g': tab[j].tab->x=6;break;
        case 'H':
    case'h': tab[j].tab->x=7;break;
        case 'I':
    case'i': tab[j].tab->x=8;break;
        case 'J':
    case'j': tab[j].tab->x=9;break;
    }
    printf("%d %d \n", tab[j].tab->x, tab[j].tab->y);
   
    }
    while( verif_coordonnees( *joueur, choix_sens, tab[j])!=1);

    if(choix_sens=='v')
    {
        for(i=0; i<tab[j].taille; i++)
        {
        strcpy(joueur->grille_jeu[tab[j].tab->x+1][tab[j].tab->y+1], tab[j].nom);
        tab[j].tab->x=tab[j].tab->x+1;
        }   
    }
    else
    if(choix_sens=='h')
    {
        for(i=0; i<tab[j].taille; i++)
        {
        strcpy(joueur->grille_jeu[tab[j].tab->x+1][tab[j].tab->y+1], tab[j].nom);
        tab[j].tab->y=tab[j].tab->y+1;
        }   
    }

printf("Votre grille de jeu : \n\n");
for(k=0; k<11; k++)
{
    for(l=0; l<11; l++)
    {
    printf("%s  ", joueur->grille_jeu[k][l]);
    }
printf("\n");
}

printf("\n");

}
}
/******************************************************************************/

/* Procedure qui affiche le menu **********************************************/
void menu(void)            
{
int choix_menu;
char chaine1[20];
char chaine2[20];

    do
    {
printf("\n");
printf("  ***   **  *****  **  * *    *    ****     *   *   **  *   *  **  *    ****\n");
printf("  *  * *  *   *   *  * * *    *    *        **  *  *  * *   * *  * *    *   \n");
printf("  ***  ****   *   **** * *    *    ****     * * *  ****  * *  **** *    ****\n");
printf("  *  * *  *   *   *  * * *    *    *        *  **  *  *  * *  *  * *    *   \n");
printf("  ***  *  *   *   *  * * **** **** ****     *   *  *  *   *   *  * **** ****\n\n\n\n");



    printf("\t\t\t************************************\n");
    printf("\t\t\t** MENU PRINCIPALE :              **\n");
    printf("\t\t\t**                                **\n");
    printf("\t\t\t**\t 1 - NOUVELLE PARTIE.     **\n");
    printf("\t\t\t**\t 2 - CHARGER UNE PARTIE.  **\n");
    printf("\t\t\t**\t 3 - QUITTER.             **\n");
    printf("\t\t\t**                                **\n");
    printf("\t\t\t************************************\n\n");
   
    printf("Que souhaitez vous faire (1/2/3) :");
    scanf("%d", &choix_menu);
    }
    while ((choix_menu < 1) || (choix_menu > 3)); /* seul 1 ,2  et 3 sont possible */

    if(choix_menu==1)
    {
    printf("\n\n");
    printf("\t\t\t************************************\n");
    printf("\t\t\t* MODE DE JEUX :                   *\n");
    printf("\t\t\t*                                  *\n");
    printf("\t\t\t*\t 1 - JOUEUR1 VS ORDINATEUR *\n");
    printf("\t\t\t*\t 2 - JOUEUR1 VS JOUEUR2    *\n");
    printf("\t\t\t*                                  *\n");
    printf("\t\t\t************************************\n\n\n");
   
    do
    {
    printf("Choisissez votre mode de jeu (1/2) : ");
    scanf("%d", &paramJoueur1.mode_jeu);
    printf("\n");
    }
    while ((paramJoueur1.mode_jeu < 1) || (paramJoueur1.mode_jeu > 2));

paramJoueur2.mode_jeu=paramJoueur1.mode_jeu;

    if(paramJoueur1.mode_jeu==2)
    {
    printf("Entrez le nom du joueur 1 : ");
    scanf("%s", chaine1);
    getchar();
    printf("\n");

    printf("Entrez le nom du joueur 2 : ");
    scanf("%s", chaine2);
    getchar();
    printf("\n\n\n");


upper(chaine1);
upper(chaine2);
printf("\t\t\t LA PARTIE OPPOSERA %s VS %s.\n", chaine1, chaine2);
    }

        if(paramJoueur1.mode_jeu==1)
    {
printf("\t\t\t************************************\n");
printf("\t\t\t* DIFFICULTE :                     *\n");
printf("\t\t\t*                                  *\n");
printf("\t\t\t*\t 1 - NORMAL                *\n");
printf("\t\t\t*\t 2 - DIFFICILE             *\n");
printf("\t\t\t*                                  *\n");
printf("\t\t\t************************************\n");
   
    do
    {
    printf("\n");
    printf("Choisissez la difficulte du jeu (1/2) : ");
    scanf("%d", &paramJoueur1.difficulte_jeu);
    printf("\n");
    }
    while ((paramJoueur1.mode_jeu< 1) || (paramJoueur1.mode_jeu > 2));
   
paramJoueur2.difficulte_jeu=paramJoueur1.difficulte_jeu;
   
    printf("Entrez le nom du joueur 1 : ");
    scanf("%s", chaine1);
    getchar();
    printf("\n\n\n");

strcpy( chaine2, "ORDINATEUR");

upper(chaine1);
upper(chaine2);
printf("\t\t\t LA PARTIE OPPOSERA %s VS %s.\n", chaine1, chaine2);
    }
   
printf("\n\n");
printf("\t\t\t***********************************\n");
printf("\t\t\t* MODE DE PLACEMENT DES BATEAUX : *\n");
printf("\t\t\t*\t1 - AUTOMATIQUE           *\n");
printf("\t\t\t*\t2 - MANUEL                *\n");
printf("\t\t\t***********************************\n\n\n");

    if(paramJoueur1.mode_jeu==2)
    {
       do
       {
       printf("%s - Choisissez votre mode de placement de bateaux : ", chaine1);
       scanf("%d", &paramJoueur1.mode_placement);
       printf("\n");
       }
       while ((paramJoueur1.mode_placement < 1) || (paramJoueur1.mode_placement > 2));
   
       do
       {
       printf("%s - Choisissez votre mode de placement de bateaux : ", chaine2);
       scanf("%d", &paramJoueur2.mode_placement);
       printf("\n");
       }
       while ((paramJoueur2.mode_placement < 1) || (paramJoueur2.mode_placement > 2));   
    }

    if(paramJoueur1.mode_jeu==1)
    {
       
       do
       {
       printf("%s - Choisissez votre mode de placement de bateaux : ", chaine1);
       scanf("%d", &paramJoueur1.mode_placement);
       printf("\n");
       }
       while ((paramJoueur1.mode_placement < 1) || (paramJoueur1.mode_placement > 2));
   
    paramJoueur2.mode_placement=1;
   
    }

    }

}
/******************************************************************************/


/******************************************************************************/
/* Programme Principale. */
int main(void)
{
joueur joueur1;
joueur joueur2;

strcpy(sousMarins.nom, "SM");
sousMarins.taille=2;

strcpy(fregate.nom, "FR");
fregate.taille=3;

strcpy(destroyer.nom, "DT");
destroyer.taille=4;

strcpy(porteAvion.nom, "PA");
porteAvion.taille=5;

tab[0]=sousMarins;
tab[1]=sousMarins;
tab[2]=fregate;
tab[3]=fregate;
tab[4]=destroyer;
tab[5]=porteAvion;


joueur1=initTabJoueur();
joueur2=initTabJoueur();

menu();
afficheTabJoueur(joueur1);
placerNavireManu(&joueur1);
afficheTabJoueur(joueur1);

system("pause");
return(0);
}
/******************************************************************************/
Pour comprendre mon probleme tester la fonction placerNavireManu toute seul puis preceder de la fonction menu.
Je remercie d'avance celui qui pourra m'aider.

J'ai survolé ce code hmm....

ceci est bizarre :

do
{
    printf("\n");
    printf("Choisissez la difficulte du jeu (1/2) : ");
    scanf("%d", &paramJoueur1.difficulte_jeu);
    printf("\n");
} 
while ((paramJoueur1.mode_jeu< 1) || (paramJoueur1.mode_jeu > 2));

Voilà deja une erreur de moins, merci Yann mais le probleme principale reside toujours .

salut j'ai regardé ton code mais je me suis arrété à la ligne 198 : if (compteur==(type.taille+2)*3)
car je n'ai pas compris ce qu'était cette variable compteur

sinon j'ai remplacé tes getchar(); par des while (getchar() != '\n');
tes noms de champ de structure et tes noms des variables en général ne sont pas claires du tout
il n'aident pas à comprendre le code
et j'ai remarqué que tu passais des structures entières en paramètre des fonction,
c'est une mauvaise habitude pourquoi ne pas passer le pointeur plutôt ?

enfin, si j'ai bien compris c'est ta fonction verif_coordonnees qui te renvoie toujours faux ?
hé bien refais la !

while(1) {
  if (i et j ne sont pas en dehors de la grille , et pion[i][j] = vide) return 0;
   i ++ si position = verticale
   j ++ si position = horizontale
}
return 1;

pardon c'est if (i et j sont en dehors de la grille , et pion[i][j] != vide) return 0;

Desolé pour les noms de mes variable et structures j essaie de les faire le plus clair possible !!
Avec les modification que tu fais est ce que ça marche !!?

ps : en fait le compteur sert a verifier que toutes les cases qui entourent le bateaux sont biens vide ("~~") pour ne pas que les bateaux se touchent !!
et (taille+2)*3 correspond a toutes les case qui entoure le navire + les case du navire !!

Ce ne serait pas :
si (i et j en dehors OU pion[i][j] != vide)

Moi ce que je te conseille, c'est de penser ton programme plus modulaire.
Cad une structure par fichier .h contenant les fonctions, constantes et variables externes qui s'y rapporte.
Des fonctions plus petites et plus précises, sans redondance, ex : une fonction d'affichage paramétrée servant à tout le programme.
Des sorties de debug dans un fichier pour valider TOUTES les valeurs changeantes.
Des ErrorHandlers pour chaque calculs.

En gros plus de reflexion en amont, avant de coder.

Bonne continuation.

Je te mets ici un .h et un .c dont je me sert tout le temps, un log de debug au format de printf :



// LOG.H

#ifndef _LOG_H_
#define _LOG_H_

#include <windows.h>

#include <stdio.h>
#include <stdarg.h>
#include <string.h>

// Appelle EcrireLog() avec la macro LOG

#if defined(_DEBUG) || defined(DEBUG)
#define LOG EcrireLog
#else
#define LOG __noop
#endif

void InitialiserLog();
void EcrireLog(const char*, ...);
void LibererLog();

#endif//_LOG_H_

////////////////////////////////////////////////////////////////

// LOG.cpp

#include "Log.h"

static FILE* g_fLogHandle = NULL;

void InitialiserLog()
{
#if defined(_DEBUG) || defined(DEBUG)

 g_fLogHandle = fopen("journalDebug.log", "wt");

#endif
}

void EcrireLog(const char* msg, ...)
{
#if defined(_DEBUG) || defined(DEBUG)

 if( g_fLogHandle != NULL )
 {
  char buffer[512];
   
  va_list v;
  va_start(v, msg);
  vsprintf(buffer, msg, v);
  va_end(v);
  
  fprintf(g_fLogHandle, "%s\n", buffer);
  fflush(g_fLogHandle);
 }

#endif
}

void LibererLog()
{
#if defined(_DEBUG) || defined(DEBUG)

 if( g_fLogHandle ) fclose(g_fLogHandle);

#endif
}

////////////////////////////////////////////////////////////////
// UTILISATION

// Debut programme
InitialiserLog();

// n'importe ou
LOG("Voici un int %d et une chaine %s", 125, "salut");

// fin programme
LibererLog();


Voilà, j'espère que ça pourra t'aider.

Merci de ton aide Yann je vais essayer d'utiliser les fichiers que tu m'as donné et je te dirais ce qu'il en est !!

YASS.