Skip to content

Instantly share code, notes, and snippets.

@vitaminac
Created June 28, 2018 20:32
Show Gist options
  • Save vitaminac/849d3097e8bc6497fabd0819ad48f6f5 to your computer and use it in GitHub Desktop.
Save vitaminac/849d3097e8bc6497fabd0819ad48f6f5 to your computer and use it in GitHub Desktop.
#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;
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment