Hack x Crack - Comunidad de Seguridad informática

Programación => Java y Android => Mensaje iniciado por: isaacolmenero99 en Febrero 14, 2018, 09:56:24 am

Título: Ayuda juego hundir la flota - JAVA
Publicado por: isaacolmenero99 en Febrero 14, 2018, 09:56:24 am
Buenas, estoy haciendo un proyecto para clase que consiste en el típico juego de hundir la flota y el problema que tengo es a la hora de introducir los barcos con su tamaño en la matriz que no entiendo como puedo printar el mapa con los barcos.
Gracias de antemano!
Título: Re:Ayuda juego hundir la flota - JAVA
Publicado por: Fuchs2013 en Febrero 14, 2018, 06:04:17 pm
Podrias poner más info, por ejemplo el código que llevas hasta ahora. Asi es más fácil ayudarte
Título: Re:Ayuda juego hundir la flota - JAVA
Publicado por: kid_goth en Febrero 14, 2018, 06:40:18 pm
un panel y con muchos labels haces la matriz, así puedes usar el setIcon y muestras la imagencita de barco que quieras
Título: Re:Ayuda juego hundir la flota - JAVA
Publicado por: isaacolmenero99 en Febrero 14, 2018, 07:17:28 pm
Podrias poner más info, por ejemplo el código que llevas hasta ahora. Asi es más fácil ayudarte

El codigo que tengo demomento simplemente es el menu de selección de juego que desee el usuario, ya sea 1vs1 o 1vsCPU, en este ultimo caso la maquina es quien decide los disparos que quiere hacer. En el modo 1vs1 es cada jugador el que elige la posición del disparo.
Previamente a todo esto cada jugador debe escoger donde quiere colocar los barcos.
Título: Re:Ayuda juego hundir la flota - JAVA
Publicado por: isaacolmenero99 en Febrero 19, 2018, 09:34:15 am
Alguna ayuda?
Título: Re:Ayuda juego hundir la flota - JAVA
Publicado por: isaacolmenero99 en Febrero 19, 2018, 10:13:35 am
Podrias poner más info, por ejemplo el código que llevas hasta ahora. Asi es más fácil ayudarte
Código: [Seleccionar]
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;
}
}
Título: Re:Ayuda juego hundir la flota - JAVA
Publicado por: ravenheart en Marzo 03, 2018, 01:21:05 pm
Puedes pintar líneas de caracteres.  · es agua, B es barco, O es disparo al agua y X es barco tocado (por ejemplo)



Título: Re:Ayuda juego hundir la flota - JAVA
Publicado por: isaacolmenero99 en Marzo 05, 2018, 10:15:16 am
Puedes pintar líneas de caracteres.  · es agua, B es barco, O es disparo al agua y X es barco tocado (por ejemplo)
Como lo harías utilizando código?
Título: Re:Ayuda juego hundir la flota - JAVA
Publicado por: animanegra en Marzo 05, 2018, 12:22:27 pm
Para pintar agua:
Código: [Seleccionar]
System.out.print(".");
Para pintar barco:
Código: [Seleccionar]
System.out.print("B");
Para pintar disparo agua:
Código: [Seleccionar]
System.out.print("O");
Y por último para pintar disparo barco:
Código: [Seleccionar]
System.out.print("X");
Título: Re:Ayuda juego hundir la flota - JAVA
Publicado por: Sp3cialK en Marzo 05, 2018, 02:35:10 pm
Supongo que la manera mas facil es que una variable numerica establezca si una celda es agua, barco, disparo o disparo barco.
Y que con ifs los pinte segun el valor de variable.
No se si me explico

Saludos!