Bonjour, j'ai un souci avec ma bataille navale je n' arrive pas faire rejouer l' ia aux alentours d'une case quand elle a touché un bateau

voici mon code :

//----------------------------------------------------------­------------------------------------------------------------­------------



//Inclusion de la librairie standard
#include <stdlib.h>
//Inclusion de la librairie d'E/S
#include <stdio.h>
//Inclusion de la librairie de temps
#include <time.h>
//inclusion de la librairie de maths
#include <math.h>
//inclusion du type jeu.h
#include "jeu.h"
//inclusion de la librairie de manipulation de chaine de caractères.
#include <string.h>


#define N 11





//Debut de la fonction
type_position position_case (int int_x,int int_y){

//on definie une case alaéatoire
type_position type_position_case;

//Affectation de x a l'abscisse de case
type_position_case.int_x = int_x ;

//Affectation de y a l'ordonnée de case
type_position_case.int_y = int_y ;

//On retourne la case.
return(type_position_case);
}



//Debut de la fonction
int type_position_x (type_position type_position_case){

//On retourne la coordonée x du type case
return(type_position_case.int_x);
}


//Debut de la fonction
int type_position_y (type_position type_position_case){

//On retourne la coordonée y de la case.
return(type_position_case.int_y);
}




//Debut de la fonction
type_grille type_grille_cons1 (void){

int i;
//Indice de boucle

int j;
//Indice de boucle

type_grille t_grille;


//Debut de la boucle
for (i = 0; i < N; i++){

//Debut de la seconde boucle

for (j = 0; j < N ; j++){

//On affecte objet initial à la case
t_grille.tint_grille[i][j] = 0;
}


}
return(t_grille);

}







//Debut de la fonction
int type_grille_l_xy (type_grille t_grille,int int_x,int int_y){
//On renvoie la valeur de la case
return(t_grille.tint_grille[int_x][int_y]);

}



type_grille type_grille_e_xy (type_grille t_grille,int int_x,int int_y,int int_objet)
{
//On ecrit objet dans la case
t_grille.tint_grille[int_x][int_y] = int_objet ;

return(t_grille);


}



//Debut de la fonction
int type_grille_nord(type_grille t_grille, int int_x, int int_y){
//si on est sur la premiere ligne
if(int_x == 0){
//on retoune la valeur de la case en ligne N colonne y
return(type_grille_l_xy(t_grille,N,int_y));

}else{
//sinon on retourne la valeur de la case au nord (x-1) colonne y
return(type_grille_l_xy(t_grille,int_x-1,int_y));
}
}





//Debut de la fonction
int type_grille_sud(type_grille t_grille, int int_x, int int_y){
//si on est sur la premiere ligne
if(int_x == N){
//on retoune la valeur de la case en ligne 0 colonne y
return(type_grille_l_xy(t_grille,0,int_y));
}else{
//sinon on retourne la valeur de la case au sud (x+1) colonne y
return(type_grille_l_xy(t_grille,int_x+1,int_y));
}
}





//Debut de la fonction
int type_grille_est(type_grille t_grille, int int_x, int int_y){
//si on est sur la dernire colonne
if(int_y == N){
//on retoune la valeur de la case en colonne 0 ligne x
return(type_grille_l_xy(t_grille,int_x,0));
}else{
//sinon on retourne la valeur de la case à l'est (y+1) ligne x
return(type_grille_l_xy(t_grille,int_x,int_y+1));
}
}





//Debut de la fonction
int type_grille_ouest(type_grille t_grille, int int_x, int int_y){
//si on est sur la premiere colonne
if(int_y == 0){
//on retoune la valeur de la case en colonne N ligne x
return(type_grille_l_xy(t_grille,int_x,N));
}else{
//sinon on retourne la valeur de la case à l'ouest (y-1) ligne x
return(type_grille_l_xy(t_grille,int_x,int_y-1));
}
}





//Debut de la fonction
int calculer_valeur_cellule (type_grille t_grille,int int_x,int int_y){
int int_nbcelluleenvieautour;//nb cellule en vie autour de la case
//Affectation de nbcellule
int_nbcelluleenvieautour = (type_grille_nord(t_grille,int_x,int_y) +
type_grille_sud(t_grille,int_x,int_y) +
type_grille_est(t_grille,int_x,int_y) +
type_grille_ouest(t_grille,int_x,int_y));
//Si la case =0 et que 3 cases autour sont en vie
if ((int_nbcelluleenvieautour == 3) &&
(type_grille_l_xy(t_grille,int_x,int_y) == 0)){
//La fonction retourne 1
return(1) ;
}
//Si il y a 3 ou 2 cellule vivante autour et que la case est en vie (=1)
if (((int_nbcelluleenvieautour == 3) || (int_nbcelluleenvieautour == 2)) &&
(type_grille_l_xy(t_grille,int_x,int_y) == 1)){
//La fonction retourne 1
return(1);
}
//S'il y a + de 3 ou - de 2 case en vie autour de la case et qu'elle vaut 1
if (((int_nbcelluleenvieautour > 3) || (int_nbcelluleenvieautour < 2)) &&
(type_grille_l_xy(t_grille,int_x,int_y) == 1)){
//La fonction renvoie 0
return(0);
}
return(0);
}






//-------------------------------------------------------------------------------------------------





//debut de la fonction
void afficher_grille (type_grille t_grille){
int i;//Indice de boucle
int j;//Indice de boucle
//Debut de la boucle
for(i=0;i<N;i++){
//On commence la ligne par |
printf("| ");
//Debut de la 2nde boucle
for(j=0;j<N;j++){
//Si la case vaut 0
if ((type_grille_l_xy(t_grille,i,j) == 0)||(type_grille_l_xy(t_grille,i,j) == 2)) {

//On affiche .
printf(" . |");

//Sinon
} else {

if (type_grille_l_xy(t_grille,i,j) == 4) {

//On affiche
printf(" T |");

} else {

if (type_grille_l_xy(t_grille,i,j) == -1) {

//On affiche
printf(" O |");

} else {

//On affiche B
printf(" B |");
}
}
}
}

//On va a la ligne
printf("\n");
}
//On va une derniere fois a la ligne
printf("\n");

}



//--------------------------------------------------------------------------------------------




int valeur_grille(type_grille t_grille) {
//on definit des variables de boucle
// d'abord i
int i;
//puis j
int j;
//variable qui va prendre le total de chaque case de la grille
int int_valeur;


//on initialise la valur a 0
int_valeur =0 ;


//on démarre une première boucle selon les abscisse
for (i = 0 ; i<N ; i++) {

//puis une seconde selon les ordonées
for (j = 0 ; j<N ; j++) {

//on regarde si la valeur de la case est inférieure a 0 c'est a dire
//soir il n'y a rien soit il y a "a l'eau"
if (type_grille_l_xy(t_grille,i,j) < 0) {

//on ajoute 0 à la valeur
int_valeur = 0 + int_valeur;

} else {


//sinon on ajoute la valeur de la case a l'addition
int_valeur = type_grille_l_xy(t_grille,i,j) + int_valeur ;

}

}
}

//et on retourne la valeur totale.

return(int_valeur);


}






//-----------------------------------------------------------------------------------------
//fonction de saisie des entiers
int lectureclavierint () {

//déclaration de deux variables qulconques.
int int_x;
int int_retour;

//on regarde la valeur de retour
int_retour = scanf("%d", &int_x);


//si elle est égale a 0
if (int_retour == 0) {

//on signale qu'il y un problème et on sort
printf("Problème de lecture\n");
exit(-1);
}

//et on retourne x
return(int_x);
}


//fonction de saisie d'un caractère
char lectureclavierchar () {

//définition d'un caractère et la valeur de retour
char char_x;
int int_retour;

int_retour = scanf("%c", &char_x);
//on regarde si la valeur de retour est égale a 0
if (int_retour == 0) {

//si elle est égale a 0 on sort et on indique qu'il y a eu un problème
printf("Problème de lecture\n");
exit(-1);
}

//puis on retourne le caractère.
return(char_x);
}


//-------------------------------------------------------------------------------------------------------------------




//fonction qui regarde sila case est occupé ou pas
int case_occupe(type_grille t_grille, int int_x,int int_y) {


//on retourne la valeur de la case.
return(type_grille_l_xy(t_grille,int_x,int_y));


}


//---------------------------------------------------------------------------------------------------------------------





//fonction permettant au joueur d'entrer les coordonée
type_grille coord_joueur(type_grille t_grille, int int_taille_bateau) {

//variable de boucle
int i;

//valeur des case:

//abscisse
int int_x;

//puis ordonée
int int_y;

//caractères pour déterminer si c'est vertical ou horizontal
char char_c;

//variable de test
int int_c;
int int_test;


//on initialise c pour entrer dans le while
char_c = 'p';

//on initialise x pour rentrer dans le while
int_x=-2;

//on initialise y pour rentrer dans le while
int_y=-2;


//tANT QU'ON A PAS LES COORDONEES DANS LA GRILLE DE BONNES
while (((int_y < 0) || (int_x < 0) || (int_x > (N-1)) || (int_y > (N-1)))
&& ((char_c != 'v') || (char_c != 'h'))){



//on fait :
//choix de l'orientation
printf("Entrer l'orientation du bateau (taille bateau = %d) ( horizontal : h ou vertical : v) \n",int_taille_bateau);


//Lecture du char
char_c = lectureclavierchar();
printf("Entrez les premiere coordonnee du Bateau (abscisse puis ordonee) \n");


//Lecture des coordonnées
int_x = lectureclavierint();
int_y = lectureclavierint();


//Suivant l'orientation
if (char_c == 'h'){


//Si on ne peux ajouter le bateau
//c'est à dire si la taille ne rentre pas en entier
if (int_x > (N-int_taille_bateau)) {

//on affecte une valeur négative a x pour continuer la boucle
int_x = -2;

}

//on initialise la variable de test a 0
int_test = 0;

//on fait une boucle afin de remplir les cases
for (i = int_x ; i < (int_x + int_taille_bateau) ; i++) {


//on regarde si la case est occupé
int_test = int_test + case_occupe(t_grille,int_y,i) ;
}


//si le test est différent de 0 c'est qu'il y a déjà une valeur donc
//on affecte -2 a x pour continuer la boucle
if (int_test != 0) {
int_x = -2;
}


} else {



//sinon si le caractère entré est v
if (char_c == 'v') {

//on regarde si la valeur de y est supérieure à la taille de la grille
//moins celle du bateau
if (int_y > (N-int_taille_bateau)) {
int_y = -2;

}
int_test = 0;
for (i = int_x ; i < (int_x + int_taille_bateau) ; i++) {
int_test = int_test + case_occupe(t_grille,i,int_x) ;
}
if (int_test != 0) {
int_y = -2;
}
}
}
//Pour vider le buffer d'entree (permet de ressaisir un char);
//Trouver sur internet :D
while ( ((int_c = getchar()) != '\n') && int_c != EOF);

}




if (char_c == 'h') {
for (i = int_x ; i < (int_x + int_taille_bateau) ; i++) {
t_grille.tint_grille[int_y][i] = 1 ;
}
}
if (char_c == 'v') {
for (i = int_x ; i < (int_x + int_taille_bateau) ; i++) {
t_grille.tint_grille[i][int_x] = 1 ;
}
}
return(t_grille);
}




type_grille init_grille_joueur (type_grille t_grille) {
int i;
for (i=1;i<6;i++) {
t_grille = coord_joueur(t_grille,i);

afficher_grille(t_grille);

}
return(t_grille);
}



//-----------------------------------------------------------------------------------------







type_grille coord_ia(type_grille t_grille, int int_taille_bateau) {


int i;
int int_x;
int int_y;
char char_c;
int int_test;

int int_val;

char_c = 'p';
int_x=-2;
int_y=-2;




//tANT QU'ON A PAS LES COORDONEES DANS LA GRILLE

while (((int_y < 0) || (int_x < 0) || (int_x > (N-1)) || (int_y > (N-1)))
&& ((char_c != 'v') || (char_c != 'h'))){

int_val = rand()%2 ;

int_x = rand()%10;

int_y =rand()%10;

if (int_val == 0) {

char_c = 'h';

} else {

char_c = 'v';

}



//Suivant l'orientation
if (char_c == 'h'){
//Si on ne peux ajouter le bateau
if (int_x > (N-int_taille_bateau)) {
int_x = -2;

}
int_test = 0;
for (i = int_x ; i < (int_x + int_taille_bateau) ; i++) {
int_test = int_test + case_occupe(t_grille,int_y,i) ;
}
if (int_test != 0) {
int_x = -2;
}
} else {
if (char_c == 'v') {
if (int_y > (N-int_taille_bateau)) {
int_y = -2;

}
int_test = 0;
for (i = int_x ; i < (int_x + int_taille_bateau) ; i++) {
int_test = int_test + case_occupe(t_grille,i,int_x) ;
}
if (int_test != 0) {
int_y = -2;
}
}
}
}




if (char_c == 'h') {
for (i = int_x ; i < (int_x + int_taille_bateau) ; i++) {
t_grille.tint_grille[int_y][i] = 2;
}
}
if (char_c == 'v') {
for (i = int_x ; i < (int_x + int_taille_bateau) ; i++) {
t_grille.tint_grille[i][int_x] = 2;
}
}
return(t_grille);
}




type_grille init_grille_ia(type_grille t_grille) {
int i;
for (i=1;i<6;i++) {
t_grille = coord_ia(t_grille,i);

}
return(t_grille);

}









//------------------------------------------------------------------------------------------------------





type_grille coup_joueur(type_grille t_grille) {


int int_x;

int int_y;

int int_retour1;

int int_retour2;




//on initialise des valeurs bidont por entrez dans le while
int_y = -1 ;

int_x= -2 ;


//tANT QU'ON A PAS LES COORDONEES DANS LA GRILLE
while ((int_y < 0) || (int_x < 0) || (int_x > 10) || (int_y > 10)) {


//on lui redemande
printf ("Tapez les coordonees du point d'impact ;) \n");


//Lecture des coordonnées

int_retour1 = scanf("%d", &int_x);

int_retour2 = scanf("%d", &int_y);


}



if ((int_retour1 == 0) || (int_retour2 == 0)) {

printf("Problème de lecture\n");

exit(-1);


} else {

if (type_grille_l_xy (t_grille,int_y,int_x) == 2) {

printf("\n");

printf("---------TOUCHE-!!---------\n");

printf("\n");

t_grille = type_grille_e_xy(t_grille,int_y,int_x,4);


afficher_grille(t_grille);


return(t_grille);



} else {

printf("\n");

printf("---------A-L-'-EAU-!!---------\n");

printf("\n");

t_grille= type_grille_e_xy (t_grille,int_y,int_x,-1);


afficher_grille(t_grille);


return(t_grille);



}

}



}








//------------------------------------------------------------------------------------------------



type_grille coup_ia(type_grille t_grille, int int_x , int int_y) {




int int_a;

int int_b;


int_x = rand()%10 ;

int_y = rand()%10 ;




if (type_grille_l_xy (t_grille,int_y,int_x) == 1) {


int_a = int_x;

int_b = int_y;



printf("\n");


printf("---------TOUCHE-!!---------\n");



printf("\n");



t_grille = type_grille_e_xy (t_grille, int_y , int_x , 4);


int_x = rand()%4;

int_y= rand()%4;


afficher_grille(t_grille);

return(t_grille);


} else {


printf("\n");


printf("---------A-L-'-EAU-!!---------\n");

printf("\n");

t_grille= type_grille_e_xy (t_grille,int_y,int_x,-1);


afficher_grille(t_grille);


return(t_grille);

}
}






//-----------------------------------------------------------------------------------------------



int menu(void) {

//On demande a l'utilisateur ce qu'il veut faire

int int_choix;

int int_result;

int int_retour;

printf("Que voulez-vous faire ? \n");

printf("\n");

printf("+--------------------------------------------------+\n");
printf("| |\n");
printf("| MENU DE JEU |\n");
printf("| |\n");
printf("+--------------------------------------------------+\n");
printf("| |\n");
printf("| |\n");
printf("|Commencer la partie..............................1|\n");
printf("|Regle de la bataille navale......................2|\n");
printf("|..................................................|\n");
printf("|..................................................|\n");
printf("|Quitter le programme.............................0|\n");
printf("+--------------------------------------------------+\n");


//on regarde son choix

int_retour =scanf("%d", &int_choix);


switch (int_choix) {


case 1 :

//si l'utilisateur rentre le choix 1 int_result prend donc 1 pour
//indiquer son choix




int_result = 1;

return (int_result);

break;

case 2 :

//si l'utilisateur rentre le choix 2 int_result prend donc 2 pour
//indiquer son choix




int_result = 2;

return(int_result);

break ;

case 0 :

//si l'utilisateur rentre le choix 0 int_result prend donc 0 pour
//indiquer son choix




int_result = 0;

return(int_result);

break ;

default :




//sinon on indique à l'utilisateur qu'il y a eu u problème de lecture


fprintf(stderr, "Problème de lecture \n") ;

exit(-1);

break;

}


}









//------------------------------------------------------------------------------------------------



int main(int argc , char** argv ) {



int int_x;

int int_y;

type_grille t_grille ;


type_grille t_grille2 ;


int int_valeur1;


int int_valeur2;




system ("clear") ;




int_x = rand()%10;


int_y=rand()%10;



srand(time(NULL));







printf(" \n \n");





printf (" ____________________________________________________________________________________\n");
printf ("| |\n");
printf ("| |\n");
printf ("| |\n");
printf ("| BATAILLE NAVALE : |\n");
printf ("| |\n");
printf ("| |\n");
printf ("|____________________________________________________________________________________|\n");







t_grille = type_grille_cons1();



t_grille2 = type_grille_cons1();


printf("\n \n \n");



printf("La grille de l'adversaire :\n \n \n");


t_grille2 = init_grille_ia(t_grille2);


afficher_grille(t_grille2);

printf("\n \n");


t_grille = init_grille_joueur(t_grille);


printf("\n \n \n");

printf("\n");

printf("Votre grille : \n");

printf("\n");


afficher_grille (t_grille);

int_valeur1 = 0;

int_valeur2 = 0;



while ((int_valeur1 < 60) && (int_valeur2 < 60)) {


printf(" \n \n");

printf("------------------A toi de jouer----------------\n \n \n");

afficher_grille (t_grille2);


printf(" \n \n \n");





t_grille2 = coup_joueur(t_grille2);



printf("--------------------Au tour de l'IA---------------\n \n \n");




t_grille = coup_ia(t_grille, int_x ,int_y);


int_valeur1 = valeur_grille(t_grille);


int_valeur2 = valeur_grille(t_grille2);



}


if (int_valeur1 == 60 ) {

printf("\n --------------------Vous avez perdu--!!-------------------\n \n \n");


} else {


printf("\n --------------------Vous avez gagne--!!--------------------\n \n \n");



}


return(0);


}

Configuration: Linux Debian
Mozilla 1.8.1.12