Foro de elhacker.net

Programación => Java => Mensaje iniciado por: sheiking en 1 Octubre 2018, 04:33 am


Título: juego de adivinar palabras en consola con 3 dificultades
Publicado por: sheiking en 1 Octubre 2018, 04:33 am
hola que tal estoy haciendo un programa que me adivine palabras y que tenga 3 dificultades pero no logro hacer que me lea las letras que escribo porque directamente me manda a la excepcion que puse en el codigo

esto es lo que llevo actualmente

package adivinapalabras;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;


public class AdivinarPalabras {
public static BufferedReader entrada = new BufferedReader (new InputStreamReader(System.in));
private static Set correctas;

String Facil[]= {"reir","hola","jugo","papa","pala","pasa","para","alma","nada","casa","mama","tele","mira","tela","bala","cera","tira"};
String Normal[]={"apretado", "avestruz","ceramica","estimulo","amarillo","eleccion","estrecho","invierno","chatarra","estrella"};
String Dificil[]={"indiscutible","participante","personalismo","perturbacion","contundencia","supervisamos","buscapleitos","vinculandose"};

public String generaPalabra(int Facil)
{
int n;
n= (int)(Math.random()*4);
if(Facil==0)
return Normal[n];

else
return Dificil[n];

}

public boolean checarLetra (char letra,String palabra )
{
boolean mensaje=false;
for(int i=0;i<palabra.length();i++)
{
if(letra==palabra.charAt(i))
{
mensaje = true;
break;
}
}
return mensaje;
}




public Set letrasPalabra(String palabra)
{
Set letras = new HashSet();
for (int i=0;i<palabra.length() ;i++)
{
if(palabra.charAt(i) != ' ')
{
letras.add(palabra.charAt(i));
}
}
return letras;
}

public String actualizaVisible(Set correctas, String palabra, String visible)
{
visible =""; boolean bandera = false;
Iterator it = correctas.iterator();
for(int i=0; i<palabra.length() ;i++)
{
while(it.hasNext())
{
char a = it.next().toString().charAt(0);
System.out.println(" "+a+" "+palabra.trim().charAt(i) );
if ( a == palabra.trim().charAt(i) )
{
visible += a; bandera = true;
break;
}
}
if (bandera == false)
{
visible += "_";
}
bandera=false; it = correctas.iterator();
}
return visible;
}





public static void main(String[] args) throws Exception {

System.out.println("Establezca el nivel de dificultad: ");
System.out.println("Facil(f)");
System.out.println("Normal(n)");
System.out.println("Dificil(d)");
String dificultad = entrada.readLine();


switch(dificultad)
{
case "f":
AdivinarPalabras Operacion = new AdivinarPalabras ();

Operacion.generaPalabra(1);

System.out.println("Palabra generada: ****");
System.out.println("teclea una letra de la palabra");
String letra = entrada.readLine();
char l=letra.charAt(0);
try
{
Operacion.checarLetra(l, letra);
Operacion.letrasPalabra(letra);
Operacion.actualizaVisible( correctas,letra,letra);
}
catch(Exception ex)
{
System.out.println("No introdujo una letra valida "+ex.getMessage());
}
case "n":
}
}
}
(http://[img][img][img][img][img][img][img][img])[/img][/img][/img][/img][/img][/img][/img][/img]

Título: Re: juego de adivinar palabras en consola con 3 dificultades
Publicado por: rub'n en 2 Octubre 2018, 01:16 am
Hola,

no veo el log por lo visto es NPE nullPointerException

claro private static Set<String> correctas; a punta a null instancia la variable de clase, "clase" porque la tienes con static

Código
  1. private static Set<String> correctas = new HashSet<>(); //
usa operador diamante <> de generics


Código
  1. public String generaPalabra(int Facil)
  2. {
  3. int n;
  4. n= (int)(Math.random()*4);
  5. if(Facil==0)
  6. return Normal[n];
  7.  
  8. else 
  9. return Dificil[n];
  10.  
  11. }

siempre dará falso porque se compara 1==0 que es falso retornando un valor random del array Difícil creo que mejor es así,

Código
  1. public String generaPalabra(final int facil) {
  2.         if (facil == 1) {
  3.             return Types.FACIL[SR.nextInt(Types.FACIL.length - 1)];
  4.         } else if (facil == 2) {
  5.             return Types.NORMAL[SR.nextInt(Types.NORMAL.length - 1)];
  6.         }
  7.         return Types.DIFICIL[SR.nextInt(Types.DIFICIL.length - 1)];
  8. }


donde
Código
  1. SR.nextInt()
para generar un numero aleatorio contenido en el largo del array fácil , y menos 1 para evitar

Código

facil tiene 17 elementos, si cae 18 daría error xq el array no es de ese tamaño pero con -1 nunca caera 18 XD

Código

método checarLetra creo que debería comparar aquí pero con la palabra que se genera de manera aleatoria con el método generaPalabra que la retorna

Código
  1. palabraGenerada = Operacion.generaPalabra(1);  // ver linea 90

si la palabra aleatoria es tela si se introduce X debería retornar false, porque x no esta en la palabra "tela"

Código
  1. public boolean checarLetra(char letra, String palabra) {
  2.         boolean mensaje = false;
  3.         for (int i = 0; i < palabra.length(); i++) {
  4.             if (letra == palabra.charAt(i)) {
  5.                 mensaje = true;
  6.                 break;
  7.             }
  8.         }
  9.         return mensaje;
  10. }

xq si lo dejas como lo tienes siempre dará true ya que compará siempre el carácter introducido con la palabra que tecleas


Aquí como parámetro dices palabra e introduces una letra ? XD o quizás dices, que cada letra correcta sea añadida al Set ?

Código
  1. public Set letrasPalabra(String palabra)
  2. {
  3. Set letras = new HashSet();
  4. for (int i=0;i<palabra.length() ;i++)
  5. {
  6. if(palabra.charAt(i) != ' ')
  7. {
  8. letras.add(palabra.charAt(i));
  9. }
  10. }
  11. return letras;
  12. }

Que deseas que haga actualizaVisible me imagino que si la letra introducida esta contenida en la palabra generada, que se reemplace el asterisco por la letra algo así  ?



Código
  1. package adivinapalabras;
  2.  
  3. public final class Types {
  4.  
  5.     public static final String FACIL[] = {"reir", "hola", "jugo", "papa", "pala", "pasa",
  6.             "para", "alma", "nada", "casa", "mama", "tele",
  7.             "mira", "tela", "bala", "cera", "tira"};
  8.  
  9.     public static final String NORMAL[] = {"apretado", "avestruz", "ceramica",
  10.             "estimulo", "amarillo", "eleccion", "estrecho",
  11.             "invierno", "chatarra", "estrella"};
  12.  
  13.     public  static final String DIFICIL[] = {"indiscutible", "participante", "personalismo",
  14.             "perturbacion", "contundencia", "supervisamos", "buscapleitos",
  15.             "vinculandose"};
  16. }
  17.  
  18.  


Código
  1. package adivinapalabras;
  2.  
  3. import java.io.BufferedReader;
  4. import java.io.InputStreamReader;
  5. import java.security.SecureRandom;
  6. import java.util.HashSet;
  7. import java.util.Iterator;
  8. import java.util.Random;
  9. import java.util.Set;
  10.  
  11. public class AdivinarPalabras {
  12.  
  13.     public static BufferedReader entrada = new BufferedReader(new InputStreamReader(System.in));
  14.     private static Set<String> correctas = new HashSet<>();
  15.     private static final SecureRandom SR = new SecureRandom();
  16.  
  17.     private static String palabraGenerada = "";
  18.  
  19.  
  20.     public String generaPalabra(final int facil) {
  21.         //int n = (int) (Math.random() * 4); no hace falta
  22.         if (facil == 1) {
  23.             return Types.FACIL[SR.nextInt(Types.FACIL.length - 1)];
  24.         } else if (facil == 2) {
  25.             return Types.NORMAL[SR.nextInt(Types.NORMAL.length - 1)];
  26.         }
  27.         return Types.DIFICIL[SR.nextInt(Types.DIFICIL.length - 1)];
  28.     }
  29.  
  30.     public boolean checarLetra(char letra, String palabra) {
  31.         boolean mensaje = false;
  32.         for (int i = 0; i < palabra.length(); i++) {
  33.             if (letra == palabra.charAt(i)) {
  34.                 mensaje = true;
  35.                 break;
  36.             }
  37.         }
  38.         return mensaje;
  39.     }
  40.  
  41.  
  42.     public Set<String> letrasPalabra(String palabra) {
  43.         //Set letras = new HashSet(); no hace falta
  44.         for (int i = 0; i < palabra.length(); i++) {
  45.             if (palabra.charAt(i) != ' ') {
  46.                 correctas.add(String.valueOf(palabra.charAt(i)));
  47.             }
  48.         }
  49.         return correctas;
  50.     }
  51.  
  52.     public String actualizaVisible(Set<String> correctas, String palabra, String visible) {
  53.         visible = "";
  54.         boolean bandera = false;
  55.         Iterator it = correctas.iterator();
  56.         for (int i = 0; i < palabra.length(); i++) {
  57.             while (it.hasNext()) {
  58.                 char a = it.next().toString().charAt(0);
  59.                 System.out.println("palabra " + a + " " + palabra.trim().charAt(i));
  60.                 if (a == palabra.trim().charAt(i)) {
  61.                     visible += a;
  62.                     bandera = true;
  63.                     break;
  64.                 }
  65.             }
  66.             if (bandera == false) {
  67.                 visible += "_";
  68.             }
  69.             bandera = false;
  70.             it = correctas.iterator();
  71.         }
  72.         return visible;
  73.     }
  74.  
  75.  
  76.     public static void main(String[] args) throws Exception {
  77.  
  78.         System.out.println("Establezca el nivel de dificultad: ");
  79.         System.out.println("Facil(f)");
  80.         System.out.println("Normal(n)");
  81.         System.out.println("Dificil(d)");
  82.         String dificultad = entrada.readLine();
  83.  
  84.  
  85.         switch (dificultad) {
  86.             case "f":
  87.                 AdivinarPalabras Operacion = new AdivinarPalabras();
  88.                 try {
  89.  
  90.                     palabraGenerada = Operacion.generaPalabra(1);
  91.                     System.out.println("Palabra generada: ****" + palabraGenerada);
  92.                     System.out.println("teclea una letra de la palabra");
  93.                     String letra = entrada.readLine();
  94.                     char l = letra.charAt(0);
  95.  
  96.                     Operacion.checarLetra(l, palabraGenerada);
  97.                      Operacion.letrasPalabra(palabraGenerada); 
  98.                     Operacion.actualizaVisible(correctas, letra, letra);
  99.  
  100.                 } catch (Exception ex) {
  101.                     ex.printStackTrace(); // usado para ver la pila de error generada
  102.                     System.out.println("No introdujo una letra valida " + ex.getMessage());
  103.                 }
  104.             case "n":
  105.         }
  106.     }
  107.  
  108. }
  109.  


Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines