Socket para troca de dados com cliente

bom dia eu to desenvolvendo uam aplicação cliente servidor que usa sockets para gerenciar um ccampeonato de par ou impar com um numero definido de participantes que seira 4 8 ou 16 jogadores

eu peguei um codigo pronto de um chat cliente-servidor na internet e to desenvolvendo em cima dele

eu consegui chegfar até a parte de que os cliente acessam o s ervidor e o servidor decide quem vai jogar com par ou impar

dai começa o meu problema

os clientes criam o socket no serviodro o servidor pega o nome deles e manda um socket de resposta qua=ndo fechou o numero de participantes definidos to testando com 4 jogadores

soh que essa resposta tinha que ser de forma automatica se fechou 4 o serviodro envia uam mensagem pedindo para o jogador digitar seu valor isso ele ainda não faz isso empaquei a apartir dai

depois de digitado o valor eo servidor teria que decidir entre os jogadores que ele iria dolocar para jogar por esemplo a posicia 0 com a 1 do meu array de jogadores quem ganhou ou perdeu e montaria novamente os novos jogos ateh sobrar somente um jogador o ganhador

eu precisava criar um metodo que apartir do que eu ja fiz fizesse isso trocasse emnsagen com os jogadores e pedisse e tratasse as jogadas ateh sobra um o ganahador

ou se algeum soubesse de algum codiggo pra mim tentar fazer que fosse mais proximo disso que eu disse

obrigado
meus codigos

servidor

import java.io.*;
import java.net.*;
import java.util.*;
public class ServidorDeChat extends Thread {
	 ArrayList jogadas;
	public ServidorDeChat(Socket s) {
		  conexao = s;
		 }
   public static void main(String args[]) {
      clientes = new Vector();
      jogadores = new Vector();
         try {
            ServerSocket s = new ServerSocket(2222);
            //interomper esse loop ai quando pendurar mais de 4 malucos ele cai fora 
              while (true) {
                 System.out.print("Esperando alguem se conectar...");
                 Socket conexao = s.accept();
                 System.out.println(s.getLocalSocketAddress());
                    Thread t = new ServidorDeChat(conexao);
                    t.start();
              }
         }catch (IOException e) {
            System.out.println("IOException: " + e);
         }
   }


   private static Vector clientes;
   private static  Vector jogadores;
   private Socket conexao;
   private String meuNome;
      public void run() {
         try {
            BufferedReader entrada = new BufferedReader(new InputStreamReader(conexao.getInputStream()));
            PrintStream saida = new PrintStream(conexao.getOutputStream());
            meuNome = entrada.readLine();
            if (meuNome == null) {return;}
            
            clientes.add(saida);
            jogadores.add(meuNome);
       	
            
       
            //clientes.add(meuNome);
               if(clientes.size()>3){
            	   
            	   String linha = entrada.readLine();
            	  
            	  for(int i=0;i<clientes.size();i++){
            		  
            		  if((i/2)==0){
            			
                        sendToAll(saida, jogadores.get(i)+" jogara com ", "par");
                         
            		  }
              	      else{
              	    	
              	    	sendToAll(saida, jogadores.get(i)+" jogara com ", "impar"); 	  
              	      }
            	   
            	  
            	   
            	        
               }
               
                 
               }
               
                  /*String linha = entrada.readLine();
                     while (linha != null && !(linha.trim().equals(""))) {
                        sendToAll(saida, " disse: ", linha);
                        linha = entrada.readLine();
                     }*/
                     //sendToAll(saida, " saiu ", "do chat!");
                     //clientes.remove(saida);
                    // conexao.close();
         }catch (IOException e) {
            System.out.println("IOException: " + e);
         }
      }   
 
 
 //meus metodos a partir daqui 
 
      
 public ArrayList partidas(Vector part){
	 
	 return jogadas;
 }
 
 
 public void sendToAll(PrintStream saida, String acao,
		  String linha) throws IOException {
		  Enumeration e = clientes.elements();
		  while (e.hasMoreElements()) {
		   // obtém o fluxo de saída de um dos clientes
		   PrintStream chat = (PrintStream) e.nextElement();
		   // envia para todos, menos para o próprio usuário
		   chat.println(meuNome + acao + linha);
		  }
 }
}


/*


import java.io.*;
import java.net.*;
import java.util.*;
public class ServidorDeChat extends Thread {
	    private Vector clientes;
	    private Socket conexao;
	    private String meuNome;
	    
   public ServidorDeChat(Socket s) {
      conexao = s;
      Vector clientes = new Vector();
	}
	 
   
   
 public static void main(String args[]) {
	 try{
	 
	 ServerSocket s = new ServerSocket(2222);
	 while (true) {
		 Socket conexao = s.accept();
		 
 	   BufferedReader entrada = new BufferedReader(new
 	        InputStreamReader(conexao.getInputStream()));
 	   PrintStream saida = new  PrintStream(conexao.getOutputStream());
 	   meuNome = entrada.readLine();
 	  if (meuNome == null) {return;}
	   clientes.add(meuNome);
 	  
 	 
	 }
	 catch (Exception e) {
		// TODO: handle exception
	}
 } 
 

 public void montachaves(Vector array){
	   for(int i =0;i<array.size();i++){
			  
		   
		   System.out.println("\n\nnome do maloka no monta chaves   "+array.get(i)+"    posicao   "+i);  	   
 }
	 
 }
 
 
    }
   }
 // enviar uma mensagem para todos, menos para o próprio
 /*public void sendToAll(PrintStream saida, String acao,
  String linha) throws IOException {
  Enumeration e = clientes.elements();
  while (e.hasMoreElements()) {
   // obtém o fluxo de saída de um dos clientes
   PrintStream chat = (PrintStream) e.nextElement();
   // envia para todos, menos para o próprio usuário
   if (chat != saida) {chat.println(meuNome + acao + linha);}
  }
 }*/
//}

cliente

import java.io.*;
import java.net.*;
public class ClienteDeChat extends Thread {
private static boolean done = false;
 public static void main(String args[]) {
  try {
    Socket conexao = new Socket("127.0.0.1", 2222);
   
   PrintStream saida = new
           PrintStream(conexao.getOutputStream());
   BufferedReader teclado =
      new BufferedReader(new InputStreamReader(System.in));
   System.out.print("Entre com o seu nome: ");
   String meuNome = teclado.readLine();
   
   saida.println(meuNome);
   
    Thread t = new ClienteDeChat(conexao);
   t.start();
   
   String linha;
   while (true) {
     //System.out.print("> ");
    
    linha = teclado.readLine();
    saida.println("jogar");
    if (done) {break;}
    saida.println("jogar");

    //System.out.println("digite o seu valor");
    //saida.println(linha);
   }
  }
  catch (IOException e) {
   System.out.println("IOException: " + e);
  }
 }

 private Socket conexao;
 public ClienteDeChat(Socket s) {
  conexao = s;
 }
 public void run() {
  try {
   BufferedReader entrada = new BufferedReader
     (new InputStreamReader(conexao.getInputStream()));
   String linha;
   while (true) {
    
    linha = entrada.readLine();
     if (linha == null) {
     System.out.println("Conexão encerrada!");
     break;
    }
    System.out.println();
    System.out.println(linha);
    System.out.print("...> ");
   }
  }
  catch (IOException e) {
   System.out.println("IOException: " + e);
  }
   done = true;
 }
}

Se eu entendi direito, você deseja que o servidor comunique aos clientes que um determinado estado (vide situação) foi atingido, certo?

A forma como os sockets trabalham é unidirecional, ou seja: a partir de um cliente você envia uma determinada mensagem a um servidor e depois a comunicação é encerrada até que outra mensagem seja enviada.

Seguindo este raciocínio, você deveria transformar todos os clientes em servidores (para “escutar” portas de comunicação vindas do servidor), e também transformar seu servidor em cliente (para enviar a mensagem aos outros clientes). Entretanto este modelo de computação não é muito elegante.

O que eu sugiro a ti é criar um controle dentro do seu servidor que indique se o número de participantes fechou. Crie uma thread nos clientes que verifique a cada ‘N’ milissegundos se o servidor já atingiu essa meta.

Desta forma você resolve outro problema: visualização do servidor em rede. Assim somente o servidor precisa ter seu endereço/IP conhecido.