Podrias poner más info, por ejemplo el código que llevas hasta ahora. Asi es más fácil ayudarte
import java.io.BufferedReader;import java.io.IOException;import java.io.InputStreamReader;public class batallanaval { private static final int VALOR_AGUA = 5; private static final int NUM_BARCOS = 5; /******************************************************************************************************** * Método principal: * - es el primer método al que llama la máquina virtual para ejecutar nuestro programa * - programamos en el el funcionamiento general del programa. Intentamos en la medida de lo posible * aislar todas las funciones que podamos identificar como principales * @param args *******************************************************************************************************/ public static void main(String[] args) { /* * Estructura de los datos: * Por cada jugador mantengo una matriz donde almaceno tanto sus barcos como los disparos que el otro * le ha realizado. La declaro como matriz de enteros porque necesito considerar varios valores * distintos, por lo que no me puede servir un dato boolean. * * La tabla de barcos de cada jugador contiene un contador por cada uno de los barcos. Cuando un tiro * da sobre un barco en particular, decremento su valor. Cuando el valor está a 0, entonces asumo que * el barco ha sido hundido. */ int[][] matrizUsuario = inicializaMatrizDisparos(); int[] barcosUsuario = inicializaTablaBarcos(); int[][] matrizMaquina = inicializaMatrizDisparos(); int[] barcosMaquina = inicializaTablaBarcos(); /* * Variables auxiliares que me sirven para llevar adelante la ejecución del método */ // Variable que utilizo para llevar el control del programa. Cuando se ponga a cierto tendré que terminar boolean haFinalizado = false; // Variable que utilizo para comprobar si un tiro de algún jugador ha sido correcto antes de actualizar // la información boolean tiroCorrecto = false; // Variable donde recojo el disparo de cada jugador. Es una tabla de dos posiciones int[] tiro = new int[2]; /* ************************************************************ * Inicialización del juego: Poner barcos (usuario y máquina) ************************************************************ */ inicializacion(matrizUsuario, matrizMaquina, barcosMaquina); /* ************************************************************ * Bucle principal del programa: se repite el juego hasta que * un jugador gana. La variable haFinalizado recoge un valor * lógico que me indica cuándo ha llegado ese punto. ************************************************************ */ while(!haFinalizado){ /* ************************************************************ * Al principio de cada turno, tengo que mostrarle al usuario * cómo se encuentra el juego: Dibujo los paneles ************************************************************ */ dibujarPaneles(matrizUsuario, barcosUsuario, matrizMaquina, barcosMaquina); /* * Mientras que no de me un disparo correcto, * le solicito un disparo correcto. */ tiroCorrecto = false; while(!tiroCorrecto) { /* * Solicito al usuario el disparo. */ tiro = pedirCasilla("Dispare:"); /* * Evaluar Tiro usuario. */ tiroCorrecto = evaluarTiro(tiro, matrizUsuario); } /* * Actualizo los datos del disparo. Si llego aquí ya se * que ha sido un disparo correcto */ actualizaMatriz(matrizUsuario, barcosUsuario, tiro); /* * Compruebo si ha terminado el juego el usuario */ haFinalizado = compruebaFin(barcosUsuario); /* * Si el usuario ha ganado, * entonces directamente terminamos. */ if(!haFinalizado){ /* * Mientras que no de me un disparo correcto, * le solicito un disparo correcto. */ tiroCorrecto = false; while(!tiroCorrecto) { tiro = generaDisparoAleatorio(); /* * Evaluar tiro de la máquina */ tiroCorrecto = evaluarTiro(tiro, matrizMaquina); } actualizaMatriz(matrizMaquina,barcosMaquina,tiro); haFinalizado = compruebaFin(barcosMaquina); } } System.out.println("Fin del juego!!!!!!"); } /********************************************************************************************** * Funciones principales llamadas desde el cuerpo del programa **********************************************************************************************/ /** * Función destinada a dibujar los paneles del usuario. */ private static void dibujarPaneles(int[][] matrizUsuario, int[] barcosUsuario, int[][] matrizMaquina, int[] barcosMaquina) { //TODO hay que crearlo. } /** * Función que una vez hemos comprobado que el tiro ha sido correcto, actualiza la información en la matriz */ private static void actualizaMatriz( int[][] matriz, int[] barcos, int[] tiro) { int valorCasilla = matriz[tiro[0]][tiro[1]]; if(valorCasilla<VALOR_AGUA) { barcos[valorCasilla]--; } matriz[tiro[0]][tiro[1]] = matriz[tiro[0]][tiro[1]] + NUM_BARCOS + 1; } /** * Función que realiza la inicialización del juego. * Su función es colocar los barcos del usuario y de la máquina */ private static void inicializacion(int[][] matrizUsuario, int[][] matrizMaquina, int[] barcos) { ponerBarcosUsuario(matrizUsuario, barcos); ponerBarcosMaquina(matrizMaquina, barcos); } /** * Función que se encarga de situar los barcos de la máquina */ private static void ponerBarcosMaquina(int[][] matrizMaquina, int[] barcos) { boolean esBarcoValido = false; int[] valoresUsuario = new int[3]; for(int i=0;i<=4;i++) // contar 5 barcos { while(!esBarcoValido) { valoresUsuario = generaBarcoAleatorio(); esBarcoValido = comprobarBarco(valoresUsuario[0], valoresUsuario[1], valoresUsuario[2]==1, barcos[i], // Tamaño del barco matrizMaquina); // Matriz de los barcos de la máquina if(esBarcoValido) { almacenaEnTabla(matrizMaquina, valoresUsuario[0], valoresUsuario[1], valoresUsuario[2]==1, barcos[i], // Tamaño del barco i); // Valor que le pongo en sus casillas } } esBarcoValido = false; } } /** * Función que se encarga de situar los barcos del usuario */ private static void ponerBarcosUsuario(int[][] matrizUsuario, int[] barcos) { boolean esBarcoValido = false; int[] valoresUsuario = new int[3]; for(int i=0;i<=4;i++) // contar 5 barcos { while(!esBarcoValido) { valoresUsuario = pedirBarcoUsuario(String.valueOf(barcos[i]) + " (barco " + (i+1) + "º)"); esBarcoValido = comprobarBarco(valoresUsuario[0], valoresUsuario[1], valoresUsuario[2]==1, barcos[i], matrizUsuario); if(esBarcoValido) { almacenaEnTabla(matrizUsuario, valoresUsuario[0], valoresUsuario[1], valoresUsuario[2]==1, barcos[i], // tamaño del barco i); //valor que le pongo en sus casillas } else System.out.println("Posición errónea"); } esBarcoValido = false; } } /** * Función que se encarga de pedir un barco al usuario. */ private static int[] pedirBarcoUsuario(String tamanhoBarco) { int[] valoresBarco = new int[3]; int[] casilla = new int[2]; char[] posicion = new char[1]; casilla = pedirCasilla("Introduzca la primera casilla del barco de tamaño " + tamanhoBarco + " (Ej: A4):"); valoresBarco[0] = casilla[0]; valoresBarco[1] = casilla[1]; posicion[0] = 'a'; while(Character.toUpperCase(posicion[0])!='V' && Character.toUpperCase(posicion[0])!='H') { // pedir posicion System.out.println("¿En qué posición quiere poner su barco? (V/H):"); posicion = leeCaracteresTeclado(1); if(Character.toUpperCase(posicion[0]) == 'H') { valoresBarco[2] = 1; } else { if(Character.toUpperCase(posicion[0]) == 'V') valoresBarco[2] = 0; } } return valoresBarco; } /** * Función que se encarga de pedir una casilla al usuario. * Se utiliza bien para pedir un disparo o bien para pedir la primera posición del barco. */ private static int[] pedirCasilla(String cadenaMensaje){ int[] valores = new int[2]; boolean encontrada = false; char[] casilla = new char [2]; char[] letras = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H'}; System.out.println(cadenaMensaje); casilla = leeCaracteresTeclado(2); //transformar la fila for(int i=0;i<8 && !encontrada;i++) { if(Character.toUpperCase(casilla[0])==letras[i]){ encontrada = true; valores[0] = i; } } if(!encontrada) valores[0]=-1; /*************************************************************** * La transformación anterior se puede hacer de esta otra manera * utilizando el caracter como valor numérico. * * valores[0] = Character.toUpperCase(casilla[0]) - 'A'; ***************************************************************/ // Columna transformada valores[1] = Character.getNumericValue(casilla[1]); return valores; } /** * Función que se encarga de actualizar la matriz una vez * que el tiro ha sido evaluado como válido */ private static void almacenaEnTabla(int[][] matriz, int fila, int columna, boolean posicion, int tamanho, int valorBarco) { if(posicion) // si el barco está en horizontal { for(int i=columna;i<=columna+tamanho-1;i++) { matriz[fila][i] = valorBarco; } } else // (si no) ==> si el barco está en vertical { for(int i=fila;i<=fila+tamanho-1;i++) { matriz[i][columna] = valorBarco; } } } /******************************************************************************************************** * Funciones para que la máquina genere valores aleatorios ********************************************************************************************************/ /** * Función que genera un disparo aleatorio. Devuelve un array de dos posiciones de entero. * La primera casilla es la fila. * La segunda casilla es la columna. */ private static int[] generaDisparoAleatorio(){ int[] valores = new int[2]; valores[0] = (int)Math.round(7*Math.random()); valores[1] = (int)Math.round(7*Math.random()); return valores; } /** * Función que genera un barco aleatorio. Devuelve un array de tres posiciones de entero. * La primera casilla es la fila. * La segunda casilla es la columna. * La tercera casilla es una valor 0 ó 1 que indica (vertical/horizontal). */ private static int[] generaBarcoAleatorio() { int[] valores = new int[3]; valores[0] = (int)Math.round(7*Math.random()); valores[1] = (int)Math.round(7*Math.random()); valores[2] = (int)Math.round(Math.random()); return valores; } /******************************************************************************************************** * Funciones que comprueban restricciones ********************************************************************************************************/ /** * Función que comprueba si hemos finalizado el juego * Se reduce a una búsqueda en un array. Busco el primer valor distinto de 0 */ private static boolean compruebaFin(int[] barcos) { for(int i=0;i<NUM_BARCOS;i++) { if(barcos[i]!=0) return false; } return true; } /** * Función que comprueba si una casilla, dadas por su fila y su columna, está dentro del tablero. */ private static boolean compruebaCasillaErronea(int fila, int columna){ return ((fila < 0 || fila > 7 || columna < 0 || columna > 7)); } /** * Función que comprueba si un barco que un jugador desea situar en algún punto del tablero es correcto. */ private static boolean comprobarBarco(int fila, int columna, boolean posicion, // True-H; False-V int tamanho, int[][] matriz) { // Se comprueba si la casilla inicial está dentro del tablero if(compruebaCasillaErronea(fila, columna)) { return false; } // Si el barco está en horizontal, compruebo que no se sale por la derecha del tablero if(posicion && (columna+tamanho-1)>7) { return false; } // Si el barco está en vertical, compruebo que no se sale por debajo del tablero if(!posicion && (fila+tamanho-1)>7) { return false; } // Si llego a este punto, es que el barco cabe dentro del tablero // Me queda por comprobar que el barco no se pisa con otros que ya estén puestos if(posicion) // si el barco está en horizontal { for(int i=columna;i<=columna+tamanho-1;i++) { if(matriz[fila][i]!=VALOR_AGUA) { return false; } } } else // (si no) ==> si el barco está en vertical { for(int i=fila;i<=fila+tamanho-1;i++) { if(matriz[i][columna]!=VALOR_AGUA) { return false; } } } // Si llego a este punto es que todas las comprobaciones se han cumplido. Devuelvo cierto (true) return true; } /** * Función que evalua si un tiro de algún jugador es correcto, es decir, es una casilla dentro del tablero * y no ha sido disparada previamente por ese mismo jugador */ private static boolean evaluarTiro(int[] valores, int[][] matriz) { // Casilla dentro del tablero // Casilla repetida?? return ( (!compruebaCasillaErronea(valores[0], valores[1])) && (matriz[valores[0]][valores[1]]<=VALOR_AGUA) ); } /********************************************************************************************************* * Funciones inicialización *********************************************************************************************************/ /** * Función que sirve para crear un panel vacío. Inicialmente, rellena todas las casillas con el valor * de "agua no disparada" (VALOR_AGUA) */ private static int[][] inicializaMatrizDisparos(){ int[][] matriz = new int[8][8]; for(int i=0;i<=7;i++) { for(int j=0;j<=7;j++) { matriz[i][j] = VALOR_AGUA; } } return matriz; } /** * Función que sirve para crear la tabla de barcos de cada jugador. Inicializa la tabla con tantas posiciones * como barcos hay, y en cada una de ellas escribe el tamaño del barco correspondiente. */ private static int[] inicializaTablaBarcos(){ int[] tablaBarcos = {5,4,3,3,2}; return tablaBarcos; } /********************************************************************************************************* * Funciones auxiliares *********************************************************************************************************/ /** * Lee un número de caracteres escritos desde el teclado * El parámetro numCaracteres es el número de caracteres que queremos leer * El resultado se devuelve en un array de ese mismo número de posiciones */ public static char[] leeCaracteresTeclado(int numCaracteres){ InputStreamReader isr = new InputStreamReader(System.in); BufferedReader br = new BufferedReader (isr); String cadena=""; char[] resultado = new char[numCaracteres]; try { while(cadena.length()<numCaracteres){ cadena = br.readLine(); if(cadena.length()<numCaracteres) System.out.println("Se espera un texto de " + numCaracteres); for(int i=0;i<numCaracteres && cadena.length()>=numCaracteres;i++) resultado[i]=cadena.charAt(i); } } catch (IOException e) { System.out.println("Error en la lectura del teclado."); } return resultado; }}
Puedes pintar líneas de caracteres. · es agua, B es barco, O es disparo al agua y X es barco tocado (por ejemplo)
System.out.print(".");
System.out.print("B");
System.out.print("O");
System.out.print("X");