Version:0.9
StartHTML:0000000105
EndHTML:0000026778
StartFragment:0000000152
EndFragment:0000026744
/******************************************************/
/*************** Isidro Pastor Jorda ******************/
/******************************************************/
/****************** Telematica ************************/
/******************************************************/
/************* Practica 6 Ejercicio 7 *****************/
/******************************************************/
/* INCLUDES */
#include <iostream.h>
#include <stdlib.h>
/* DEFINICION DE CONSTANTES */
const int FILAS = 4; // Filas de nuestro tablero
const int COLUMNAS = 4; // Columnas de nuestro tablero
const int BARCOS = 5; // Esta constante corresponde al numero de barcos que introduciremos en el tablero
/* DEFINICION DE TIPOS DE DATOS */
typedef char tablero[FILAS][COLUMNAS]; // El tablero es una matriz de FILASxCOLUMNAS de tipo char.
/* PROTOTIPOS DE LAS FUNCIONES QUE USAREMOS */
void InicializaMatriz(tablero M, char reset) ;
void IntroducirBarcos(tablero j);
void MostrarMatriz(tablero M);
bool BuscaGanador(tablero j);
bool MiraHundido(tablero tabla,int i,int j);
int main()
{
/* Definicion de variables */
tablero j1, j2;
bool hundido, ganador, tocado;
int jugador, i, j;
/* Presentacion del programa */
cout << "*************************************************\n";
cout << "***************_***********___*******************\n";
cout << "**************/ \\********___|__******************\n";
cout << "**************\\_/*******| |*****************\n";
cout << "***************|********|______|*****************\n";
cout << "***************|**********| |*******************\n";
cout << "********______/ \\_________| |____***************\n";
cout << "******_/ \\_*************\n";
cout << "*****| HUNDIR LA FLOTA '02 \\************\n";
cout << "******\\_____________________________/************\n";
cout << "*************************************************\n";
cout << "************ Isidro Pastor Jorda ****************\n";
cout << "*************************************************\n";
cout << "*************** TELEMATICA **********************\n";
cout << "*************************************************\n";
cout << "\n Juego de Hundir la Flota " << endl;
/* Proceso de introduccion de los barcos */
cout << "\n Inicio de la introduccion de los 5 barcos " << endl;
cout << " Jugador 1 introduce sus barcos \n";
InicializaMatriz(j1, 'a'); // inicializamos la matriz del jugador 1 con todo agua
IntroducirBarcos(j1); // Llamada a la funcion para introducir los barcos
cout << " \n Tu tablero completo es este: " ;
MostrarMatriz(j1);// muestra el tablero por pantalla para comprobar la introduccion de los barcos
cin.ignore(); // Eliminamos el buffer para usar cin.get() y esperar a pulsar una tecla para continuar
cout << "\n Pulsa INTRO para continuar ";
cin.get(); // leemos la tecla y podemos continuar nuestra introduccion de barcos
system("CLS"); // Borramos la pantalla con una llamada a system
cout << " Jugador 2 introduce sus barcos \n";
InicializaMatriz(j2, 'a'); // Inicializamos el tablero del jugador 2 todo con agua
IntroducirBarcos(j2); // Llamada a la funcion de introducir los barcos
cout << " \n Tu tablero completo es este: ";
MostrarMatriz(j2); // Muestra el tablero por pantalla
cin.ignore();
cout << "\n Pulsa INTRO para continuar ";
cin.get();
system("CLS");
/* FIN DE LA INTRODUCCION DE DATOS */
jugador = 1; // Inicializamos jugador a 1 ya que empieza jugando este jugador
ganador = false; // no existe todavia un ganador luego iniciamos ganador a false
/* AQUI EMPIEZA LA BASE DEL JUEGO QUE SE REPITE PARA CADA TIRADA DE CADA JUGADOR */
do // Este do..while repetira todas las acciones de tiradas mientras no haya un ganador (ganador=true)
{
tocado = false; // Inicializamos tocado a false por si acaso ...
cout << "\n Jugador " << jugador << endl;
do // do..while de control de errores, para no bombardear fuera del tablero
{
cout << " Dime la casilla que quieres bombardear -> ";
cin >> i >> j; // leemos por teclado los valores introducidos de fila y columna a bombardear
if ( i < 0 || i >= FILAS || j < 0 || j >= COLUMNAS )
cout << "\n Has excecido el tamaņo de la matriz, Vuelve a intentarlo \n";
}
while ( i < 0 || i >= FILAS || j < 0 || j >= COLUMNAS );
if (jugador == 1) // Si juega el jugador 1 realizaremos la siguientes tareas
{
if ( j2[i][j] == 'a') // si en el tablero del jugador 2 la posicion bombardeada es agua
cout << "\n AGUA \n"; // simplemente mostramos por pantalla que hemos tocado AGUA
if ( j2[i][j] == 'b')// Si hemos tocado un barco realizaremos las siguientes acciones ....
{
cout << "\n TOCADO \n";// mostramos por pantalla que un barco ha sido tocado
tocado = true; // Damos el valor true a tocado para realizar la secuencia posterior de busqueda de hundido y ganador
j2[i][j] = 'a'; // en la posicion donde estaba el barco antes lo pasamos a agua, el barco ya esta tocado
}
if ( tocado ) // si el barco ha sido tocado en este movimiento
{
hundido = MiraHundido(j2, i, j);// llamamos a la funcion que buscara si el barco ha sido tambien hundido
ganador = BuscaGanador(j2); // Llamamos a la funcion que nos busca si el jugador que ha tirado es ganador
if ( hundido ) // Si el barco ha sido hundido tambien mostramos por pantalla HUNDIDO
cout << "\n HUNDIDO \n";
}
}
if (jugador == 2) // Si el jugador es el 2 el proceso es el mismo solo que pasando el tablero 1 a las funciones
{
if ( j1[i][j] == 'a')
cout << "\n AGUA \n";
if ( j1[i][j] == 'b')
{
cout << "\n TOCADO \n";
tocado = true;
j1[i][j] = 'a';
}
if ( tocado )
{
hundido = MiraHundido(j1, i, j);
ganador = BuscaGanador(j1);
if ( hundido )
cout << "\n HUNDIDO \n";
}
}
if ( ganador ) // Si hay un ganador .... (ganador = true)
cout << " \n HA GANADO EL JUGADOR " << jugador << " !!!!! "; // Mostramos por pantalla el jugador ganador
if (jugador == 1)// Si estamos jugando con el jugador 1 en esta mano
jugador = 2; // En la siguiente el jugador sera el 2
else
jugador = 1; // en caso contrario esta mano la ha jugado el jugador 2 por lo tanto la siguiente lo hara el 1
}
while ( !ganador);// Condicion de permanencia para el do..while inicial del bucle de juego
system("PAUSE");
return 0;
}
/* FIN DEL PROGRAMA PRINCIPAL */
/* COMIENZO DEL DESARROLLO DE LAS FUNCIONES */
void MostrarMatriz(tablero M)
{
cout << endl << endl;
for (int i = 0; i < FILAS; i++ )
{
for (int j = 0; j< COLUMNAS; j++)
cout << " " << M[i][j];
cout << endl;
}
}
/******************************************************************
* Funcion: InicializaMatriz
* Descripcion: Funcion que inicializa una matriz al valor de reset
*
*
* Parametros:
*
* Nombre E/S Descripcion
* ------ ----- -----------
* M E/S Matriz a inicializar
* reset E Valor usado para inicializar la matriz
*
* Valor devuelto:
* void, la matriz no devuelve nada pero modifica el vector
*******************************************************************/
void InicializaMatriz(tablero M, char reset)
{
for (int i = 0; i < FILAS; i++ )
for (int j = 0; j< COLUMNAS; j++)
M[i][j] = reset;
return;
}
/***********************************************************************************
* Funcion: IntroducirBarcos
* Descripcion: Funcion desde la que introduciremos los barcos en la matriz
*
*
* Parametros:
*
* Nombre E/S Descripcion
* ------ ----- -----------
* tabla E/S de tipo tablero donde introduciremos los barcos
*
*
* Valor devuelto:
* void, aqui modificaremos la matriz que se nos de para introducir los barcos
***********************************************************************************/
void IntroducirBarcos(tablero tabla)
{
int i, j;
i = 0;
j = 0;
for ( int contador = 1; contador <= BARCOS; contador++)
{
do // Primer do..while de control de errores, nos servira para no introducir dos veces un barco en la misma casilla
{
do // Segundo do..while de control de errores, para controlar que no nos salgamos de las filas y columnas
{
cout << " Introduce los valores de i,j donde quieres introducir el barco numero " << contador << " -> " ;
cin >> i >> j;
if ( i < 0 || i > FILAS-1 || j < 0 || j > COLUMNAS -1 ) // mensaje de error si nos excedemos en filas o columnas
cout << " Error, se ha excedido del tamanyo del tablero, i maxima = "<< FILAS - 1 << " j maxima = " << COLUMNAS - 1 << endl;
}
while ( i < 0 || i > FILAS - 1 || j < 0 || j > COLUMNAS - 1);// condicion de permanencia segundo do..while
if ( tabla[i][j] == 'b') // Salida por pantalla en el primer do..while del error cometido
cout << " \n Error la casilla ya tenia un barco introducido \n" ;
}
while ( tabla[i][j] == 'b');// condicion de permanencia del primer do..while
tabla[i][j] = 'b' ;// si hemos superado los controles de errores grabamos en la posicion introducida un barco
}// fin del for que se repetira hasta haber rellenado con todos los barcos el tablero
}
/****************************************************************************************************
* Funcion: MiraHundido
* Descripcion: Funcion que devolvera true si encuentra barcos alrededor o false si es todo agua
*
*
* Parametros:
*
* Nombre E/S Descripcion
* ------ ----- -----------
* tabla E/S de tipo tablero donde introduciremos los barcos
* i E Valor de la posicion de la fila introducida por teclado
* j E Valor de la columna introducida por teclado
*
* Valor devuelto:
* BOOL, La funcion devuelve hundido si no se detectan barcos alrededor del punto de introduccion
*****************************************************************************************************/
bool MiraHundido(tablero tabla,int i,int j)
{
bool hundido;
hundido = true; // Deinimos la variable que devolveremos como salida de la funcion, la iniciamos a true.
int k ;
int l ;
for (k = i-1; k <= i + 1 ; k++) // iniciamos nuestro contador en i-1 e ira hasta i+1, que es la submatriz que queda alrededor de i,j
{ for (l = j-1; l <= j + 1; l++) // La variable de las columnas ira desde j-1 hasta j+1
{
/* cuando hacemos el bucle entraremos a veces en posiciones que no existen en nuestra
matriz por lo tanto debemos evitar que tomen valores en estas posiciones para evitar
resultados que no sabemos que dan, por lo tanto hacemos un if previo para solamente
ejecutar nuestra comprobacion en el vector sobre puntos que si existen en la matriz */
if ( k >= 0 && l >= 0 && k < FILAS && l < COLUMNAS)
{
if ( tabla[k][l] == 'b')
hundido = false;
}
}
}
return (hundido);
}
/***********************************************************************************
* Funcion: BuscaGanador
* Descripcion: Funcion que buscara en la matriz tablero si ya existe un ganador comprobando
que todas las entradas de la matriz son agua
*
*
* Parametros:
*
* Nombre E/S Descripcion
* ------ ----- -----------
* tabla E/S de tipo tablero donde introduciremos los barcos
*
*
* Valor devuelto:
* void, aqui modificaremos la matriz que se nos de para introducir los barcos
***********************************************************************************/
bool BuscaGanador(tablero tabla)
{
bool ganador = true; // Inicializamos nuestra variable a true
for (int i=0; i< FILAS; i++)
{
for (int j = 0; j < COLUMNAS; j++) // recorremos la matriz entera con estos dos bucles
{
if (tabla[i][j] == 'b' ) // Si encontramos algun barco en el tablero no habra ganador todavia
ganador = false; // por lo tanto devolveremos un valor false a nuestra funcion
}
}
return (ganador);
}