batalla_naval.c

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define NMAX 10 //numero maximo de filas y de columnas
#define NMAXCASILLAS 20 //cantidad de casillas x 4*1+3*2+2*3+1*4

void GRAFICAR_T(char Tablero[NMAX][NMAX],int de_quien_es);
void INICIAR_TABLERO(char Tablero[NMAX][NMAX]);

//colocar barco
void PONER_BARCO_Jugador(int tamanoBarco, char Tablero[NMAX][NMAX]);
void PONER_BARCO_Ordenador(int tamanoBarco, char Tablero[NMAX][NMAX]);

//disparo de turno
void NUEVO_TURNO(char Tablero_enemigo[NMAX][NMAX],int quien);

//devuelve la cantidad de casilla con 'H' que significa hundido
int NUMERO_DE_HUNDIDOS(const char T[NMAX][NMAX]);

//escribe los simbolos que se grafican en un tablero
void Normas_SIM()
{
	printf("\n\n");
	printf("Simbologia\n");
	printf(" : desconocido para enemigo\n");
	printf("X: barco, invisible para enemigo\n");
	printf("A: agua\n");
	printf("T: tocado\n");
	printf("H: hundidos\n");
	printf("\n\n");
}

enum Quien
{
	jugador,
	ordenador
};

enum Bool {
	falso,
	verdadero
};

enum Disparo
{
	siguiente_turno,
	otroDisparo
};

int main()
{
	int ganador;

	//iniciar el tablero
	char T_Jugador[NMAX][NMAX];
	char T_Ordenador[NMAX][NMAX];
	INICIAR_TABLERO(T_Jugador);
	INICIAR_TABLERO(T_Ordenador);

	srand(time(NULL));//nueva seed para aleatorizar

	//colocar todos los barco de jugador
	PONER_BARCO_Jugador(4, T_Jugador);//barco de 4 casillas
	PONER_BARCO_Jugador(3, T_Jugador);//barco de 3 casillas
	PONER_BARCO_Jugador(3, T_Jugador);//barco de 3 casillas
	PONER_BARCO_Jugador(2, T_Jugador);//barco de 2 casillas
	PONER_BARCO_Jugador(2, T_Jugador);//barco de 2 casillas
	PONER_BARCO_Jugador(2, T_Jugador);//barco de 2 casillas
	PONER_BARCO_Jugador(1, T_Jugador);//barco de 1 casillas
	PONER_BARCO_Jugador(1, T_Jugador);//barco de 1 casillas
	PONER_BARCO_Jugador(1, T_Jugador);//barco de 1 casillas
	PONER_BARCO_Jugador(1, T_Jugador);//barco de 1 casillas

	//colocar todos los barco de ordenador
	PONER_BARCO_Ordenador(4, T_Ordenador);//barco de 4 casillas
	PONER_BARCO_Ordenador(3, T_Ordenador);//barco de 3 casillas
	PONER_BARCO_Ordenador(3, T_Ordenador);//barco de 3 casillas
	PONER_BARCO_Ordenador(2, T_Ordenador);//barco de 2 casillas
	PONER_BARCO_Ordenador(2, T_Ordenador);//barco de 2 casillas
	PONER_BARCO_Ordenador(2, T_Ordenador);//barco de 2 casillas
	PONER_BARCO_Ordenador(1, T_Ordenador);//barco de 1 casillas
	PONER_BARCO_Ordenador(1, T_Ordenador);//barco de 1 casillas
	PONER_BARCO_Ordenador(1, T_Ordenador);//barco de 1 casillas
	PONER_BARCO_Ordenador(1, T_Ordenador);//barco de 1 casillas

	/*test
	printf("Este es tablero de ordenador");
	GRAFICAR_T(T_Ordenador, jugador);
	system("pause");
	*/

	//empieza la partida
	Normas_SIM();
	int turno = jugador;//turno de jugador
	while (verdadero)
	{
		if (turno % 2 == jugador) //turno de jugador
		{
			system("cls");
			GRAFICAR_T(T_Jugador, jugador);
			//el jugador juegue una vez terminado cambia turno para que la proxima le toque al ordenador
			NUEVO_TURNO(T_Ordenador, jugador);
			if (NUMERO_DE_HUNDIDOS(T_Ordenador) == NMAXCASILLAS) {
				ganador = jugador;
				break;
			}
			
		}
		else //toca de ordenador
		{
			system("cls");
			GRAFICAR_T(T_Ordenador, ordenador);
			NUEVO_TURNO(T_Jugador, ordenador);
			if (NUMERO_DE_HUNDIDOS(T_Jugador) == NMAXCASILLAS) {
				ganador = ordenador;
				break;
			}
		}
		turno++;//cambiando turno
	}
	if (ganador == jugador) {
		printf("Enhorabuena has ganador\n");
	}
	else
	{
		printf("Has perdido\\n");
	}
	return 0;
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////										SUBPROGRAMA CONMUN							/////////////////////////	
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////

//Rellenar el tablero con ' '
void INICIAR_TABLERO(char Tablero[NMAX][NMAX]) {
	int i, j;
	for (i = 0; i < NMAX; i++) {
		for (j = 0; j < NMAX; j++) {
			Tablero[i][j] = ' ';
		}
	}
}

//Muestra el tableros dado segun si es jugador o ordenador
void GRAFICAR_T(char Tablero[NMAX][NMAX],int de_quien_es)//jugador = 1,ordenador = 0
{
	int i, j;
	if (de_quien_es == jugador) {
		printf("Tablero de jugador");
	}
	else
	{
		printf("Tablero de ordenador");
	}
	printf("\n\n  ");
	for (j = 0; j<NMAX; j++)
	{
		printf("%d", j);
	}
	printf("\n\n");
	if (de_quien_es == jugador)
	{
		for (i = 0; i<NMAX; i++)
		{
			printf("%d ", i);
			for (j = 0; j<NMAX; j++)
			{
				putchar(Tablero[i][j]);
			}
			printf("\n");
		}
	}
	else
	{
		for (i = 0; i<NMAX; i++)
		{
			printf("%d ", i);
			for (j = 0; j<NMAX; j++)
			{
				if (Tablero[i][j] != 'X') {
					putchar(Tablero[i][j]);
				}
				else
				{
					putchar(' ');
				}
			}
			printf("\n");
		}
	}

	printf("\n\n");
}

void PREGUNTAR_POSICION(int* nf,int *nc) {
	printf("Ingrese numero de fila y luego numero de columna\n");
	scanf("%d", nf);
	scanf("%d", nc);
}

void TONTO_ORDENADOR(int* nf, int *nc,int rango) {//genera aleatoriamente la posicion
	*nf = rand() % rango;
	*nc = rand() % rango;
}

int Haya_Barco_Alrededor(int nf, int nc, const char T[NMAX][NMAX]) {
	int i, j;
	for (i = nf - 1; i < nf + 2; i++) {
		for (j = nc -1; j < nc + 2; j++) {
				if (T[i][j] == 'X' && !((i<0) || (j<0) || (i>NMAX - 1) || (j>NMAX - 1)))
				{
					return verdadero;
				}
		}
	}
	return falso;
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////						       PREPARACION DE PARTIDA							/////////////////////////	
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/*
comprueba si al poner nueve barco choca con otro o si choca con los bordes
devuelve verdadero(1) si toca con algo y falso(0) en caso contrario
*/
int NO_SE_PUEDE_PONER(int nf, int nc, char orientacion, int tamanioBarco, const char Tablero[NMAX][NMAX])
{
	int i, j;

	if (orientacion != 'v')//horizontal
	{
		if (nc + tamanioBarco>NMAX)
		{
			return verdadero;
		}
		else
		{
			for (j = nc; j < nc + tamanioBarco; j++) {
				if (Haya_Barco_Alrededor(nf,j,Tablero)) {
					return verdadero;
				}
			}
		}
	}
	else//vertical
	{
		if (nf + tamanioBarco>NMAX)
		{
			return verdadero;
		}
		else
		{
			for (i = nf; i < nf + tamanioBarco; i++) {
				if (Haya_Barco_Alrededor(i, nc, Tablero)) {
					return verdadero;
				}
			}
		}
	}

	return falso;
}


//Segun el tamaño del barco se coloca el barco con origen (nf,nc) vertical u horizontalmente devuelve 1,si se hace con exito
void PONER_BARCO(int nf, int nc, char orientacion, int tamanoBarco, char Tablero[NMAX][NMAX]){
	int k;
	if (orientacion == 'v')
	{
		for (k = 0; k<tamanoBarco; k++)
			Tablero[nf + k][nc] = 'X';
	}
	else
	{
		for (k = 0; k<tamanoBarco; k++)
			Tablero[nf][nc + k] = 'X';
	}
}

//Pregunta la posicion y la orientacion de barco para colocarlo con la llamada de PONER_BARCO
void PONER_BARCO_Jugador(int tamanoBarco, char Tablero[NMAX][NMAX]) {
	int nc, nf;
	char orientacion;
	do
	{
		system("cls");
		GRAFICAR_T(Tablero, jugador);
		printf("Tamano del barco %d.", tamanoBarco);
		PREGUNTAR_POSICION(&nf, &nc);
		printf("Ingresar v=Vertical o cualquier otro valor para Horizontal\n");
		while (getchar() != '\n');
		orientacion = getchar();
	} while (NO_SE_PUEDE_PONER(nf, nc, orientacion, tamanoBarco, Tablero));
	PONER_BARCO(nf, nc, orientacion, tamanoBarco, Tablero);
	system("cls");
	printf("El Barco se ha cargado con exito quedo de la siguiente forma\n");
	GRAFICAR_T(Tablero, jugador);
	system("pause");
}

void PONER_BARCO_Ordenador(int tamanoBarco, char T[NMAX][NMAX]) {
	int nf,nc;
	char orientacion;
	do
	{
		TONTO_ORDENADOR(&nf, &nc,NMAX - tamanoBarco + 1);
		orientacion = 'v' + rand() % 2;
	} while (NO_SE_PUEDE_PONER(nf, nc, orientacion, tamanoBarco, T));
	PONER_BARCO(nf, nc, orientacion, tamanoBarco, T);
}


////////////////////////////////////////////////////////////////
//////// COMIENZO DE LA PARTIDA, JUGADOR VS ORDENADOR       ///
//////////////////////////////////////////////////////////////

int Todos_tocado(int nf_anterior, int nc_anterior, int nf, int nc, const char Tablero[NMAX][NMAX]) {
	int barco = Haya_Barco_Alrededor(nf, nc, Tablero);
	if (barco)
	{
		return falso;
	}
	for (int i = nf-1; i < nf+2; i++)
	{
		for (int j = nc -1; j < nc+2; j++)
		{
			if ((Tablero[i][j] == 'T') && ((i != nf_anterior) || (j != nc_anterior)) && ((i != nf) || (j != nc)) && !((i<0) || (j<0) || (i>NMAX - 1) || (j>NMAX - 1))) {
				barco += !Todos_tocado(nf, nc, i, j,Tablero);
			}
		}
	}
	if (barco == 0) {
		return verdadero;
	}
	else
	{
		return falso;
	}
}

int HUNDIR_BARCO(int nf,int nc, char T[NMAX][NMAX]) {
	T[nf][nc] = 'H';
	for (int i = nf - 1; i < nf + 2; i++) {
		for (int j = nc -1; j < nc + 2; j++) {
			if ((T[i][j] == 'T') && ((i!=nf) || (j != nc)) && !((i<0) || (j<0) || (i>NMAX - 1) || (j>NMAX - 1))) {
				HUNDIR_BARCO(i, j, T);
			}
		}
	}
	return verdadero;
}


//realizara un "disparo" sobre la flota contraria,si ha tocado devuelve 1
int DISPARO(int nf,int nc, char Tablero_enemogos[NMAX][NMAX]) {
	//GRAFICAR_T(Tablero_enemogos, jugador);
	if (Tablero_enemogos[nf][nc] == 'X')
	{
		Tablero_enemogos[nf][nc] = 'T';
		if (Todos_tocado(-1, -1, nf, nc, Tablero_enemogos))
		{
			HUNDIR_BARCO(nf, nc, Tablero_enemogos);
			printf("Barco Hundido!\n");
		}
		printf("Has acertado, obtiene una nueva optunidad\n");
		return otroDisparo;

	}
	else if (Tablero_enemogos[nf][nc] == ' ') {
		Tablero_enemogos[nf][nc] = 'A';
		return siguiente_turno;
	}
	return siguiente_turno;
}

void NUEVO_TURNO(char Tablero_enemogos[NMAX][NMAX], int quien) {
	int nf, nc;
	if (quien == jugador) {
		printf("Presione una tecla para comenzar tu turno\n");
		do {
			system("pause");
			system("cls");
			printf("Tablero de enemigos\n\n");
			GRAFICAR_T(Tablero_enemogos, ordenador);
			do {
				PREGUNTAR_POSICION(&nf, &nc);
			} while ((Tablero_enemogos[nf][nc] == 'A') && (Tablero_enemogos[nf][nc] == 'T') && (Tablero_enemogos[nf][nc] == 'H'));
		} while (DISPARO(nf, nc, Tablero_enemogos) && (NUMERO_DE_HUNDIDOS(Tablero_enemogos) != NMAXCASILLAS));
	}
	else
	{

		printf("Presione una tecla para que juegue el ordenador\n");
		system("pause");
		do {
			system("cls");
			printf("Turno de ordenador\n\n");
			printf("Mis tablero\n\n");
			GRAFICAR_T(Tablero_enemogos, jugador);
			system("pause");
			do {
				TONTO_ORDENADOR(&nf, &nc,10);
			} while ((Tablero_enemogos[nf][nc] == 'A') && (Tablero_enemogos[nf][nc] == 'T') && (Tablero_enemogos[nf][nc] == 'H'));
		} while (DISPARO(nf, nc, Tablero_enemogos) && (NUMERO_DE_HUNDIDOS(Tablero_enemogos) != NMAXCASILLAS));
	}
}


//devuelve la cantidad de casilla con 'H' que significa hundido
int NUMERO_DE_HUNDIDOS(const char T[NMAX][NMAX])
{
	int i, j;
	int cantidadDeHundidos = 0;
	for (i = 0; i<NMAX; i++)
	{
		for (j = 0; j<NMAX; j++)
		{
			if (T[i][j] == 'H')
			{
				cantidadDeHundidos++;
			}
		}
	}
	return cantidadDeHundidos;
}