[Java] Duda servidores TCP

cerverus94 #1 May '14

Veréis, resulta que estoy practicando java y tengo dudas de como adaptar este código para servidores TCP

import java.util.Scanner;
public class JuegoLingo 
{
	/**
	 * Variable de tipo Scanner, que usaremos para recoger datos por teclado.
	 */
	Scanner teclado = new Scanner(System.in);

/**
 * Main
 * @param args
 */
public static void main(String[] args) {
	// TODO Auto-generated method stub

	JuegoLingo juego=new JuegoLingo();
	
	
	do{ // bucle do while, que se ejecutara mientras el jugador quiera seguir jugando
	Jugador Contacto = new Jugador(); // Creamos un nuevo jugador
	System.out.print("------------------------------------------------------------\nBienvenido a Aprende Ingles con el LINGO\n");
	System.out.print("¡Adivina la palabra de cinco letras! Tienes cinco intentos.\n * : letra correcta en posicion correcta \n ? : letra correcta pero posicion erronea \n - : letra no existente en la palabra a adivinar\n ------------------------------------------------------------\n");
	juego.nuevoNombre(Contacto);	//Pedimos el nombre al jugador	
	Palabra newWord = new Palabra();	// generamos una palabra	
	
	do{ // bucle de juego
	Contacto.fallo(); // le sumamos un fallo al jugador ( como empieza con "-1" fallos, la primera vez se pondra a 0)
	newWord.mostrarGuiones(Contacto.getFallosRestantes()); // mostramos la palabra con guiones, las coincidencias, y las oportunidades restantes
	newWord.comprobarPalabra(juego.getPalabra()); // comprobamos los aciertos del jugador
	}while(Contacto.getFallosRestantes()>0 && !newWord.victoria()); // el bucle de juego se ejecutara mientras el jugador no haya ganado, o tenga oportunidades
	
	if(newWord.victoria()){ // si el jugador ha ganado mostraremos el mensaje de victoria
		juego.victoria(Contacto);
	}else{ // si el jugador ha perdido mostraremos el mensaje de derrota
		juego.perder(Contacto);
	}
	
	}while(juego.seguirJugando()); // volveremos a ejecutar el juego mientras el jugador quiera seguir jugando.
	
}

/**
 * Metodo que cambia el nombre del jugador
 * @param recibe el jugador como parametro
 */
private void nuevoNombre(Jugador Contacto){
	System.out.print("¿Como te llamas?:");
	String Nombre = teclado.nextLine();
	Contacto.setNombre(Nombre);
	
}
/**
 * Pide al jugador que introduzca una palabra
 * @return la palabra introducida por el usuario
 */
private String getPalabra(){
	String palabraIntroducida;
	do{
	System.out.print("Introduce palabra:");
	palabraIntroducida = teclado.nextLine();
	}while(palabraIntroducida.length()!=5);
	return palabraIntroducida;
}
/**
 * Pregunta al jugador si quiere seguir jugando
 * @return true si quiere seguir jugando, false si no quiere seguir jugando
 */
private boolean seguirJugando(){
	System.out.print("¿Otra partida?Si/No:");
	String opcion;
	do{
	opcion = teclado.nextLine();
	if(!opcion.toUpperCase().equals("SI") && !opcion.toUpperCase().equals("NO")){
		System.out.print("Opcion no valida, introduce una opcion válida:");
	}
	}while(!opcion.toUpperCase().equals("SI") && !opcion.toUpperCase().equals("NO"));
	if(opcion.toUpperCase().equals("NO")){
		return false;
	}
	return true;
}
/**
 * Mensaje de victoria
 * @param recibe el jugador como parametro
 */
private void victoria(Jugador contacto){
	
	System.out.println("\n¡¡Felicidades "+contacto.getNombre()+", has adivinado la palabra!!\n");
	System.out.println("--------------------------");
	System.out.println("Has obtenido "+contacto.getPuntuacion()+" puntos");
	System.out.println("--------------------------");
}

/**
 * Mensaje de derrota
 * @param recibe el jugador como parametro
 */
private void perder(Jugador contacto){		
	System.out.println("\nOhhhhh! "+contacto.getNombre()+", has perdido!!\n");
	System.out.println("--------------------------");
	System.out.println("Has obtenido "+contacto.getPuntuacion()+" puntos");
	System.out.println("--------------------------");
}

}

Clase jugador

public class Jugador {
	/**
	 * Nombre del jugador.
	 */
	private String nombre;
	/**
	 * Numero de oportunidades iniciales.
	 */
	private int oportunidades=5;
	/**
	 * Numero de fallos. Empezamos con "-1" porque la primera vez que entra en el bucle de juego, esto lo cambia a 0.
	 */
	private int fallos=-1;
	

/**
 * Constructor.
 */
public Jugador()
{
}
/**
 * 
 * @return nombre del jugador.
 */
public String getNombre() 
{
	return nombre;
}
/**
 * 
 * @param string nombre.
 */
public void setNombre(String nombre)
{
	this.nombre = nombre;
}

/**
 * 
 * @return numero restante de oportunidades.
 */
public int getFallosRestantes()
{
	return oportunidades-fallos;
}
/**
 * Suma uno al numero de fallos.
 */
public void fallo(){
	fallos++;
}
/**
 * 
 * @return puntuacion.
 */
public int getPuntuacion()
{
    return (oportunidades-fallos)*500;	
}



}

Clase Palabra

public class Palabra {
	/**
	 * Lista de palabras en ingles para el juego.
	 */
	private String Lista[]={"Black","Metal","Elder","Storm","Heavy","Piece","Space","Noire", "Speed", "Final", "Saint", "Class", "Cover", "Chart", "Graph", "Great", "Grown", "Green", "Taste", "Sense", "Sorry", "Dirty", "Party", "State", "Study", "Store", "Until", "These", "Three", "Tired", "Store", "Stake", "Tough", "Loose", "Laugh", "Leave", "Light", "Point", "Catch", "Could", "Reach", "React", "Break", "Bread", "Doubt", "Table", "Power", "Still", "Issue", "Lemon" };
	/**
	 * Palabra elegida en Mayusculas.
	 */
	private String palabraMayusculas; // aqui guardaremos la palabra elegida en mayusculas, para que sea mas facil comparar
	/**
	 * Palabra que usaremos para las coincidencias.
	 */
	private String palabraCoincidencias; // una String que nos guarda los guiones
	/**
	 * Palabra que mostraremos al jugador, con las letras que ya ha acertado.
	 */
	private String palabraMostrar;
	
/**
 * Constructor
 */
public Palabra() {
	int a = (int) (Math.random() * Lista.length); //generamos un numero aleatorio entre 0 y el tamaño de la lista de palabras
	
	palabraMayusculas = Lista[a].toUpperCase(); // asignamos el juego en la posicion "a" al String palabraMayusculas
	palabraMostrar = palabraMayusculas;
	
	for(int i=1; i<palabraMostrar.length();i++){  //ponemos un numero de guiones igual al numero de caracteres del juego, respetando los espacio
		
		palabraMostrar = palabraMostrar.substring(0,i)+"_"+palabraMostrar.substring(i+1);
		
	}
	palabraCoincidencias = "*"+palabraMostrar.substring(1); //La primera letra de palabraCoincidencias siempre coincide, porque ya te la dan
	System.out.print("Adivina la palabra: "); //Imprimimos por primera vez la palabra, como pista.
	for(int i=0;i<palabraMostrar.length();i++){
		
		System.out.print(palabraMostrar.charAt(i)+" "); //imprimimos el caracter en "i" seguido de un espacio, para dejar espacios
	}
	System.out.println();
}
/**
 * En esta función mostraremos la palabra con las letras ya descubiertas, seguido de las coincidencias que ha tenido el jugador y el numero de oportunidades que le quedan
 * @param fallos cometidos por el jugador
 */
public void mostrarGuiones(int fallos) {
	System.out.println();
	for(int i=0;i<palabraMostrar.length();i++){ //mostramos la palabra con las letras ya descubiertas
		
		System.out.print(palabraMostrar.charAt(i)+" ");
	}
	System.out.print("\t Coincidencias:");
	
	for(int i=0;i<palabraCoincidencias.length();i++){ // mostramos las coincidencias que ha tenido el jugador
		
		System.out.print(palabraCoincidencias.charAt(i)+" ");
	}
	System.out.print("\tTe quedan "+fallos+" oportunidades\n\n"); // le mostramos el numero de oportunidades restantes
	
}
/**
 * En esta funcion comprobaremos los aciertos que ha tenido el jugador.
 * @param palabra introducida por el usuario a comparar
 */
public void comprobarPalabra(String nuevaPalabra){
	if(nuevaPalabra.toUpperCase().equals(palabraMayusculas)){ // Si la palabra es la correcta hacemos un return
		palabraMostrar = palabraMayusculas;
		return;
	}
	for(int i=1;i<palabraMayusculas.length();i++){ // bucle en el que recorremos las letras de la palabra buscando coincidencias
		if(nuevaPalabra.toUpperCase().charAt(i) == palabraMayusculas.charAt(i)){ // si la letra coincide en la misma posicion la sustituimos  en "PalabraMostrar" y en "palabraCoincidencias"
			palabraCoincidencias = palabraCoincidencias.substring(0, i)+"*"+palabraCoincidencias.substring(i+1);
			palabraMostrar = palabraMostrar.substring(0,i)+nuevaPalabra.toUpperCase().charAt(i)+palabraMostrar.substring(i+1);
		}else{ //Si no coincide en la misma posicion, comprobamos el resto de posiciones por si esa misma letra estuviera en otra posicion.
			boolean letraPresente = false; // esta variable sirve para saber si la letra esta presente en la palabra o no
			for(int j=1;j<palabraMayusculas.length();j++){
				if(nuevaPalabra.toUpperCase().charAt(i) == palabraMayusculas.charAt(j)){
					palabraCoincidencias = palabraCoincidencias.substring(0, i)+"?"+palabraCoincidencias.substring(i+1);;
					letraPresente = true;
					break;
				}
			}
			if(!letraPresente){// Si no esta presente la letra que estamos comparando devolvemos esa posicion a un "_", por si acaso estaba cambiada de una oportunidad anterior
				palabraCoincidencias = palabraCoincidencias.substring(0, i)+"_"+palabraCoincidencias.substring(i+1);;

			}
		}
	}		
}


/**
 * Comprobamos si el jugador ha ganado ya.
 * @return true si el jugador ya ha adivinado la palabra, false si no lo ha conseguido aun.
 */
public boolean victoria() {
	if(palabraMostrar.equals(palabraMayusculas)){
		return true;
	}
	return false;
}
}

La cosa es que la teoría la se pero me lio con los BufferedReader y los PrintWriter porque no se como coordinarlos >.<

SikorZ #2 May '14 El Gran Carlemany

Disculpa, que es un servidor TCP para ti? Es que no le encuentro mucho sentido a toda tu pregunta en general...

1 respuesta

cerverus94 #3 May '14

#2 Es esto por ejemplo

Cliente

/**
* Cliente TCP que envía cadena de caracteres al servidor
* y espera recibir cual es la mayor al introducir una 
* linea con un punto.
*
* * @version 1.0
*/
import java.net.*;
import java.io.*;
/**
* Cliente TCP que envía cadenas a un servidor hasta enviar una cadena
* con un punto. El servidor responderá con la cadena mayor las enviadas
*
* @author Redes y Entornos Multijugador
* @version 1.0
*/
import java.util.Scanner;


public class ClienteTCP {

public static void main(String[] args) {
	
	Scanner teclado= new Scanner(System.in);
	String cadena;

	try{
		Socket s= new Socket ("localhost", 12334);
		PrintWriter salida= new PrintWriter(s.getOutputStream(),true);
		BufferedReader entrada= new BufferedReader (new InputStreamReader(s.getInputStream()));
		
		do{
			//leo de teclado
			System.out.println ("Introduzca linea:");
			cadena=teclado.nextLine();
			//envio
			salida.println(cadena);
			
			//recepcion:
			System.out.println ("recibo:"+ entrada.readLine());
			
		}while(!cadena.equals("."));
			
		
		
		teclado.close();
		salida.close();
		entrada.close();
		s.close();
		
		
	}catch (Exception e){
		e.printStackTrace();
	}
}
}

Servidor

/**
* Servidor TCP que lee cadenas hasta recibir un punto e
* indica cual de ellas es mayor
*

* @version 1.0
*/
import java.io.*;
import java.net.*;


public class ServidorTCP {

public static void main(String[] args) {
	
	String cadena_mayor="";

	try {
		//se crea servidor en el puerto 12334
		ServerSocket serv= new ServerSocket (12334, 3);  //pongo una cola de espera de 4 peticiones
		System.out.println ("Servidor creado en el puerto: "+ serv.getLocalPort());
		//el servidor espera la conexion de un cliente
		while (true){
			
			//creamos socket y flujos 
			Socket c= serv.accept();	
			PrintWriter salida= new PrintWriter (c.getOutputStream(), true);
			BufferedReader entrada= new BufferedReader (new InputStreamReader (c.getInputStream()));
			
			//leemos lineas hasta el punto y comparamos
			String info= entrada.readLine();	
			while (!info.equals(".")){
				if (info.length() > cadena_mayor.length())
					cadena_mayor= info;
				salida.println(info);
				info= entrada.readLine();
			}
			
			//Cuando la cadena leida ya sea "." envio la mas larga
			salida.println ("la cadena mas larga es: \""+cadena_mayor+"\" , y su longitud es "+ cadena_mayor.length()); 

			entrada.close();
			salida.close();
			c.close();
			
			//antes de terminar dejo inicializada la variable cadena_mayor para el siguiente cliente
			cadena_mayor="";	
		}

	} catch (IOException e) {
		e.printStackTrace();
		
	} catch (SecurityException e) {
		e.printStackTrace();
	}
}

}

Simplemente estoy practicando

SikorZ #4 May '14 El Gran Carlemany

Ah, te refieres a sockets, vale xD... esq sonaba raro, nunca escuche a nadie llamarlos asi.

Me pillas q me iba a sobar y que no he toqueteado mucho eso en java, si luego se me aperece la virgen te intento echar un cable

Fyn4r #5 May '14 Inocente

Pero cual es el problema exactamente?

cerverus94 #6 May '14

Que no se aplicar el flujo de datos entre el servidor y el cliente por el socket

1 respuesta

Dostoievski #7 May '14

#6 Acostumbrate a poner un flush() después de los print.

Ese código te está funcionando? En un primer vistazo no le veo ningún problema, di el por qué no furula como esperas ;P

1 respuesta

cerverus94 #8 May '14

#7 Si que me furula lo único que estoy intentando poner son sockets (Cliente y servidor) y no consigo como adaptar bien el código.

1 respuesta

ratontm #9 May '14

#8 Pues lo ideal sería que utilizaras hilos dentro de la clase principal para manejar a cada cliente, sino es imposible manejar más de uno (si es lo que quieres hacer).

Te aconsejo, y mucho, que te mires este ejemplo de un chat utilizando Sockets, lo explica todo muy bien y verás con un ejemplo como aplicar lo que te digo antes. Además en ese utilizan también hilos en los clientes para manejar los mensajes que le llegan del servidor.

El caso es el siguiente, tu en el servidor creas un Socket y los clientes se conectan a ese Socket, cada nuevo socket que conecta con el servidor (cliente) se inicia en un hilo nuevo, para poder manejarlos.

spoiler

[Java] Duda servidores TCP

Usuarios habituales

Tags