Jogo Stop_Online em Java

LeandroNDias · Dezembro 6, 2009, 8:20pm

Olá a todos do Fórum.

Estou com algumas dúvidas em um projeto que estou fazendo em parceria de alguns colegas, o tema é um jogo online chamado Stop_Online, 90% do código foi de autoria de outras pessoas,odeio ter que pegar projetos como referência mas como estou sem tempo vai ter que ser assim mesmo… tanto porque mal conheço o Java básico.

São 2 projetos java um para o servidor e outro para os jogadores, estou com dúvidas quanto a conexão do projeto dos jogadores para o projeto do servidor que já esta implementado.

Vou postar abaixo as classes principais de cada projeto Cliente e Servidor.

Projeto Cliente - Classe Jogador<<<<<<<<<<

“A parte que precisa ser fixada é a do método Conecta, preciso colocar o método main em algum local deste código também para que esta classe fique como principal.”

package stop_online;
/**

Applet que e utilizado como iterface para o jogo.
toda a parte grafica foi feita utilizando o pacote awt para poder ser o mais
compativel possivel com qqer plataforma
/
import java.awt.;
import java.awt.event.;
import java.applet.Applet;
import java.util.;
import java.net.URL;
import java.rmi.;
import java.rmi.server.;

public class Jogador extends Applet implements JogadorInterface,
ActionListener {

public static final int LOGIN = 0; // Sala 1
public static final int ESPERANDO = 1; // Sala 2
public static final int JOGANDO = 2; // Sala 3
public static final int CONTABILIZANDO = 3; // Sala 4
public static final int VENDOPONTOS = 4; // Sala 5

private int estado = LOGIN;

private String nome_str;
private Vector turnos; // Vetor com objetos do tipo Turno

private StopServerInterface sserver; //Atribuindo um alias a interface Stopserver

// APPLET

private String letra = “”; //essa variavel tem que ser mandada pelo servidor
private Button login; //botão que manda o login pro servidor
private Button stop; //botão que manda o STOP pro servidor
private Button jogar;
// esse botao só é necessario pra pasear pelas telas, ele deve ser trocado
//por um comando do servidor
private Button recomecar;
// esse botao só é necessario pra pasear pelas telas, ele deve ser trocado
//por um comando do servidor

private TextField nome;

private Panel pSalaLogin; //Panel que representa a tela de Login
private Panel pSalaJogo; //Panel que representa a tela do Jogo
private Panel pSalaEspera; //Panel que representa a tela de Espera
private Panel pSalaPontos; //Panel que representa a tela dos Pontos
private Panel pSalaIntermediaria;//Panel que representa a tela Intermediaria

private Vector campos; //vetor com os TextFields do Stop
private Vector camposResposta;//vetor com os textos escritos durante o Stop

/**

Constroi um Jogador com o nome dado.
Seta o seu estado para DESCONECTADO.
@param nome o nome do jogador.
*/
//Método de conexão com o Servidor Stop que retorna um
//vector com a lista de jogadores
public Vector conecta() {

Exception ee;

try {
// exporta o applet como um objeto remoto
System.out.println(“Jogador.init: Exportando objeto”);
try {
UnicastRemoteObject.exportObject(this);
ee = null;
} catch (java.rmi.server.ExportException e) {
// use already exported object; remember exception
ee = e;
}

// lookup StockWatch server
URL base = getDocumentBase();
String serverName = “//” + getParameter(“server”) + “:”
+ getParameter(“1066”) + “/stop.StopServerImpl”;
System.out.println("Jogador.init: Procurando servidor: "+serverName);
sserver = (StopServerInterface)Naming.lookup(serverName);
/*
try {
String name = “//” + args[0] + “/Compute”;
Compute comp = (Compute) Naming.lookup(name);
Pi task = new Pi(Integer.parseInt(args[1]));
BigDecimal pi = (BigDecimal) (comp.execute.Task(task));
System.out.println(pi);
} catch (Exception e) { }
*/

// ?(StopServer)Naming // Recebe o nome do servidor
//atribuida ao alias da interface StopServer
// interface.classe.método(atributo);
} catch (Exception e) {
System.out.println("exception occurred during initialization; "
+ “check the log”);
System.out.println(e.getClass().getName() + ": " + e.getMessage());

// fatal error
System.out.println("got exception: " + e.getMessage());
e.printStackTrace();
return null;
}

// Após conectar recebe lista de jogadores conectados
Vector lista_jogadores = null;
try{
System.out.println("Conectando ao servidor de Stop " );
lista_jogadores = sserver.novoJogador(this);
}
catch (RemoteException e){ //Tratamento de erros ao receber novos jogadores
System.out.println("exception occurred during server novoJogador " );
System.exit(0);
}

return lista_jogadores;
}

/**
*

REMOTE
Inicia um novo turno em um jogo em andamento.
@param turno o novo Turno do jogo.
*/
public void novoTurno(Turno turno) {
this.turnos.add( turno );
System.out.println(“Jogador.novoTurno: Iniciando nova rodada ! " +
“(letra=”+turno.getLetra()+”)");
letra = turno.getLetra();
salaJogo();
update(false); //Atualiza status atual do turno aberto true ou fechado false

}

/**

REMOTE
Executa um stop no turno atual e devolve o turno com as respostas prenchidas

*/
public Turno stopJogo() throws RemoteException{

if(this.estado != Jogador.JOGANDO )
  return null;

update(false);

pegaValores();
turnoAtual().setRespostas( camposResposta );
zeraRespostas();

return turnoAtual();

}

/**

REMOTE
Monta sala de pontuacao
*/
public void mostraPontos( Hashtable respostasDosJogadores )
throws RemoteException {

// System.out.println("Jogador.pontos = "+ respostasDosJogadores);

if ((respostasDosJogadores != null) && (respostasDosJogadores.size() > 0)){

//System.out.println(“UPDATE: Dados do turno :
//” + turnoAtual().getColunas().toString());

  Iterator nomeJogadores = (Iterator) respostasDosJogadores.keys();
  
  Vector jogadores = new Vector();
  Vector pontos    = new Vector();

  while( nomeJogadores.hasNext() ) {
String nome = (String)nomeJogadores.next();
Turno turno = (Turno)respostasDosJogadores.get( nome );
String p = Integer.toString( turno.getTotalPontos() );
System.out.println(" Nome = "+nome+" Pontos = " + p );

jogadores.add( nome );
pontos.add( p );

  }
  
  salaPontos( pontos, jogadores, false );
  update(false);

}

}

/**

REMOTE

*/
public String getNome(){
return this.nome_str;
}

public Turno turnoAtual(){
return (Turno)turnos.lastElement();
}

/**

Inicializa o applet, montando algumas salas que nao dependem do servidor
*/

public void init()
{

campos = new Vector();
camposResposta = new Vector();
turnos = new Vector();

salaLogin();
salaIntermediaria();	
// nao precisa montar as outras telas aqui


this.setLayout(new BorderLayout());
this.add("Center", pSalaLogin);

}

public void pegaValores()
{
Iterator iter = (Iterator) campos.elements();

while (iter.hasNext()){
  TextField textTemp = (TextField)iter.next();
  String s = textTemp.getText();
  System.out.println("Jogador: Resposta = ("+s+")");

if(s.startsWith(letra.toUpperCase()) || s.startsWith(letra.toLowerCase())){
camposResposta.add(s.trim());
}
else {
camposResposta.add("");
}
}

System.out.println("Jogador: Respostas="+camposResposta.toString());

}

/**

este metodo monta a tela de login, � sempre a
primeira sala que o jogador ver�
a verifica��o se o jogador colocou um nome esta
no metodo que cuida do evento do bot�o
*/

public void salaLogin()
{
pSalaLogin = new Panel(new FlowLayout(FlowLayout.CENTER));

pSalaLogin.add(new Label("Nome"));
nome = new TextField("", 30);
pSalaLogin.add(nome);
login = new Button("Jogar!!");
login.addActionListener(this);    
pSalaLogin.add(login);

}

/**

Monta o layout da sala de Espera que � onde o novo jogador fica
at� come�ar um novo turno do Jogo
recebe a letra que esta sendo usado na partida sendo jogada
e um vetor com os jogadores que est�o jogando

*/

public void salaEspera(Vector jogadores)
{
pSalaEspera = new Panel(new GridLayout(0, 1));

Iterator iter = (Iterator) jogadores.elements();

this.letra = ((String)iter.next());
    
pSalaEspera.add(new Label("a letra sendo jogada &#65533;:" + letra));
pSalaEspera.add(new Label("Pessoas Jogando:", Label.CENTER));


String jogAux;
while (iter.hasNext()){
  jogAux = ((String)iter.next());
  pSalaEspera.add(new Label(jogAux, Label.CENTER));
}

pSalaEspera.add(new Label("aguarde a rodada acabar para poder começ" +
        "ar a jogar", Label.CENTER));
// essa parte do bot&#65533;o n&#65533;o &#65533; necess&#65533;ria no applet final, isso sera
//feito pelo servidor

}

/**

Este metodo monta a tela do jogo mesmo, recebe do
servidor um vetor de categorias
e a letra da rodada atravez de uma Estrutura Turno
ainda nao coloquei recebendo um turno… fa�o isso
depois, mas depois que colocar o turno
basta pegar as categorias e a letr dele e pronto
*/

public void salaJogo() //estudar
{
pSalaJogo = new Panel( new BorderLayout());
pSalaJogo.add(“North”, new Label("Letra Valendo: " +
turnoAtual().getLetra()));
Panel pJogo = new Panel( new GridLayout(0, 2));

Vector categorias = turnoAtual().getCategorias();
//Enumeração das categorias
Iterator iterC = (Iterator) categorias.elements();

pJogo.add(new Label("Categorias"));
pJogo.add(new Label("Respostas"));

campos = new Vector();
while (iterC.hasNext()){
  pJogo.add(new Label((String)iterC.next() + ":"));
  TextField text = new TextField("", 30);
  campos.addElement(text);
  pJogo.add(text);
}
stop = new Button("Stop");
stop.addActionListener(this);
pSalaJogo.add("Center", pJogo);
pSalaJogo.add("South", stop);

}

/**

Esta � uma tela intermediaria enquanto o servidor nao
manda quantos pontos * cada jogador fez
*/

public void salaIntermediaria() {
pSalaIntermediaria = new Panel(new BorderLayout());
pSalaIntermediaria.add(“Center”, new Label("Contabilizando os " +
“Pontos…”, Label.CENTER));
}

/**

Este metodo mostra os pontos obtidos na ultima rodada, esses pontos tem que
ser mandados pelo servidor atrav�s de dois vetores, um de jogadores e um de
pontos, os pontos do jogador i estao na posicao i do vetor de pontos
*/

public void salaPontos(Vector pontos, Vector jogadores, boolean terminou)
{
pSalaPontos = new Panel(new BorderLayout());
Panel pAux = new Panel(new GridLayout(0, 2));

Iterator iterP = (Iterator) pontos.elements();
Iterator iterJ = (Iterator) jogadores.elements();

pAux.add(new Label("Jogador"));
pAux.add(new Label("Pontos"));
int maiorPontuacao = -1;
String vencedor = "";

System.out.println("Montando layout!!!");
while (iterJ.hasNext()){
  String jogadorAux = (String)iterJ.next();
  String pontosAux  = (String)iterP.next();

  if(maiorPontuacao < Integer.parseInt(pontosAux)){
vencedor = jogadorAux;
maiorPontuacao = Integer.parseInt(pontosAux);
  }
  pAux.add(new Label(jogadorAux + ":"));
  pAux.add(new Label(pontosAux));
}
if(terminou){	// monta um Panel dando os parabens a quem ganhou
  pSalaPontos.add("South", new Label("Parabens " + vencedor +
          ", voc&#65533; foi o grande vencedor"));
}

pSalaPontos.add(“North”, new Label(“Letra da Rodada:” + letra, Label.CENTER));
pSalaPontos.add(“Center”, pAux);
//esta parte � feita pelo servidor, nao precisa desse bot�o pra mudar de tela

}

/**

este metodo verifica quando o jogador apertou algum dos bot�es do applet
e toma as devidas provid�ncias
*/

public void actionPerformed(ActionEvent evt)
{
if (evt.getSource() == login){
TextField t = (TextField) pSalaLogin.getComponent(1);
if(t.getText().equals("")){
// o jogador nao preencheu o nome
this.add(“North”, new Label("Coloco um nome antes de come�ar " +
“a jogar”,Label.CENTER));
this.validate();
}
else {
// avisa o servidor que quer jogar, pega os dados e vai pra sala de espera
nome_str = t.getText();

// Conecta ao servidor e preenche o Vector com lista de jogares
Vector lista_jogadores = conecta();

System.out.println("Lista de Jogadores: "+lista_jogadores.toString());


salaEspera( lista_jogadores );

update(false);

  }
}

//essa parte do if vai sair daqui ja que o servidor que altera pra tela de jogo

else if(evt.getSource() == stop){
  // avisa o servidor que ele deu um Stop, e espera o servidor
    //muda-lo pra tela Intermediaria
  
try{
  System.out.println("Jogador: Enviando STOP para o servidor" );
  sserver.stop(this);
}catch (RemoteException e) {
  System.out.println("Jogador: REMOTE EXCEPTION no stop() " );
  System.exit(0);
}

//      pegaValores();
// manda respostas pro servidor		
         
}

}

/**

pega os campos da tela do jogo e os limpa
senao na proxima rodada valores antigos aparecer�o
*/

public void zeraRespostas()
{
Iterator iter = (Iterator) campos.elements();
while (iter.hasNext()){
TextField t = (TextField)iter.next();
t.setText("");
camposResposta.removeAllElements();
}
}

/**

esse metodo � chamado pelo servidor e atualiza ent�o a tela do applet
antes de chamar esse metodo o servidor tem que montar o panel que
sera usado chamando o metodo correnpondente
@param acabouPartida diz se deve encerrar essa partida ou nao
*/

public void update(boolean acabouPartida)
//A cada estado em cada condição é processado o placar do turno atual
{
if(estado == LOGIN){
this.removeAll();
this.add(“Center”, pSalaEspera);

   estado = ESPERANDO;
 }
 else if(estado == ESPERANDO){

   this.removeAll();
   this.add("Center", pSalaJogo);
	  
   estado = JOGANDO;
 }
 else if(estado == JOGANDO){

   this.removeAll();
   this.add("Center", pSalaIntermediaria);
   
   estado = CONTABILIZANDO;
 }
 else if(estado == CONTABILIZANDO){

   this.removeAll();
   this.add("Center", pSalaPontos);
   
   estado = VENDOPONTOS;
 }                                     //true
 else if((estado == VENDOPONTOS) && (!acabouPartida)){

   this.removeAll();
   this.add("Center", pSalaJogo);

   estado = JOGANDO;
 }                                    //false
 else if((estado == VENDOPONTOS) && (acabouPartida)){

   this.removeAll();
   this.add("Center", pSalaEspera);
   
   estado = ESPERANDO;
 }
  
 this.validate();

}
}

Projeto Servidor>>Classe StopServer<<<

package stop_online_server;

import java.rmi.Naming;
import java.rmi.RMISecurityManager;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
import java.rmi.server.UnicastRemoteObject;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Vector;

public class StopServerImpl extends UnicastRemoteObject
implements StopServerInterface, Runnable{
private static final long serialVersionUID = 1L;

public static final int STAND_BY = 0;
public static final int RUNNING = 1;
public static final int STOPED = 2;

private int id; /* ID do servidor */

private Vector jogadores;
private Turno turnoAtual;

private int estado;
private int tempo_espera;

private int TIMEOUT_START = 50000;
private int TIMEOUT_STOP = 500000;

/* thread temporizador para notificar o start e
stop ( caso ninguem tenha apertado o botao )*/
private Thread timer = null;

public StopServerImpl( int id ) throws RemoteException {
this.id = id;
this.turnoAtual = new Turno( Turno.sorteiaLetra(), id,
Turno.getCategDefault());
this.jogadores = new Vector();
this.estado = STAND_BY;

// start thread para iniciar Jogo (se houver jogadores )
this.timer = new Thread(this, “timerSTART”);
timer.start();

}

// *Retorna um Vector com a primeira posicao sendo a letra sorteada
//e as seguintes os jogadores conectados */
public Vector lista_jogadores(){

Vector v = new Vector(); //

v.add( turnoAtual.getLetra() );
Iterator it = (Iterator) jogadores.elements();
while(it.hasNext()){
JogadorInterface jogador = ((JogadorInterface)it.next());
try{
v.add( jogador.getNome());
} catch (RemoteException ex) {
System.out.println("StopServer.getNome(): REMOTE EXCEPTION : " +
“Removendo jogador da lista”);
removeJogador( jogador );

}

return v;
}

/**

REMOTE
Acrescenta um jogador na lista de jogadores.

*/
public Vector novoJogador(JogadorInterface jogador)
{

 try {
   System.out.println("StopServer: novoJogador ("+jogador.getNome()+")\n");
 } catch (RemoteException ex) {
System.out.println("StopServer.getNome(): REMOTE EXCEPTION : " +
            "Removendo jogador da lista");
removeJogador( jogador );
 }


 // adiciona jogador na lista
if (!jogadores.contains( jogador )) {
    jogadores.addElement( jogador );
}

// Retorna um vector padrao (letra + usuarios)
  return lista_jogadores();

}

/**
*

REMOTE

*/
public int stop(JogadorInterface jogador) {

System.out.println(“StopServer: Executado stop \n”);
estado = STOPED;
stopTodosJogadores(jogador);

return 1;
}

/**

Executa stopJogo em todos os jogadores,
contabiliza os pontos e guarda nos objetos Coluna dos jogadores
*/
public void stopTodosJogadores(JogadorInterface jogador_stop)
{

System.out.println(“StopServer: Executando stopTodosJogadores\n”);

// So contera pontos dos jogadores ativos.
// KEY = jogador
// VALUE = Vector de objs do tipo Coluna
Hashtable respostasDosJogadores = new Hashtable();

Iterator it = (Iterator) jogadores.elements();

//Le respostas dos jogadores

while( it.hasNext() ) {
JogadorInterface jogador = (JogadorInterface)it.next();
try {
System.out.println("StopServer.stopTodosJogadores: sending " +
"stopJogo para: " + jogador.getNome());
Turno turno = jogador.stopJogo();

if (turno != null){
  String n = jogador.getNome();
  if (jogador_stop != null) {
    String nome_stop = jogador_stop.getNome();
    if (n.equals(nome_stop)){
      System.out.println(" Nome : "+n+" apertou STOP\n");
      n = n + " (apertou STOP!)";
    }
  }

  
  respostasDosJogadores.put( n, turno);
}


} catch (RemoteException ex) {
System.out.println("StopServer.getNome(): REMOTE EXCEPTION : " +
            "Removendo jogador da lista");
removeJogador( jogador );
}

}

int colNum;
for (colNum = 0; colNum < turnoAtual.numColunas() ; colNum++ ){

 // Ocorrencia de palavras por coluna da categoria
 // KEY   = palavra
 // VALUE = num de ocorrencias
 Hashtable ocorrenciasColuna = new Hashtable();

 Iterator resps = (Iterator) respostasDosJogadores.elements();

 // Calcular ocorrencias
 while( resps.hasNext() ) {
   Turno turno = (Turno)resps.next();
 Vector colsResposta = turno.getColunas();

   Coluna coluna = (Coluna)colsResposta.get(colNum);

 if( coluna.getResposta() != null){
   if ( !ocorrenciasColuna.containsKey( coluna.getResposta() )) {
     ocorrenciasColuna.put( coluna.getResposta(), new Integer(1));
   }else{
     ocorrenciasColuna.put( coluna.getResposta(), new Integer(2));
   }
 }
 }


resps =   (Iterator) respostasDosJogadores.elements();

 // Calcular  os pontos por jogador
 while( resps.hasNext() ) {

   Turno turno = (Turno)resps.next();
 Vector colsResposta = turno.getColunas();
   Coluna coluna = (Coluna)colsResposta.get(colNum);

 int pontos;

if (coluna.getResposta() != null && (coluna.getResposta().length() > 3)){
if ( ((Integer)ocorrenciasColuna.get( coluna.getResposta() )).intValue() == 2){
pontos = 5;
}else{
pontos = 10;
}
}else{
pontos = 0;
}

 coluna.setPontos( pontos);
 turno.incrPontos( pontos );
 }

}

//System.out.println("StopServer.Pontos = "+respostasDosJogadores.toString());

it = (Iterator) jogadores.elements();

// UPDATE em todos os jogadores
while( it.hasNext() ) {
JogadorInterface jogador = (JogadorInterface)it.next();
try{
System.out.println("Enviando pontos para : "+jogador.getNome()+ “\n”);

jogador.mostraPontos( respostasDosJogadores );  

} catch(RemoteException ex) {
System.out.println("StopServer.mostraPontos(): " +
            "REMOTE EXCEPTION : Removendo jogador da lista");
removeJogador( jogador );
}

}

this.estado = STAND_BY;
this.timer = new Thread(this, “timerSTART”);
timer.start();

}

public void removeJogador( JogadorInterface jogador){
jogadores.removeElement( jogador );
}

/**

Executa novoJogo em todos jogadores
*/
public void novoTurno() {
turnoAtual = new Turno( Turno.sorteiaLetra(), 1, Turno.getCategDefault() );

Iterator it = (Iterator) jogadores.elements();
while(it.hasNext()){
JogadorInterface jogador = (JogadorInterface)it.next();
try{
jogador.novoTurno( turnoAtual.clone2() );

} catch (RemoteException ex) {
  System.out.println("StopServer.novoTurno(): remote exception");
  //ex.printStackTrace();
  removeJogador(jogador);
}

}

estado = RUNNING;
this.timer = new Thread(this, “timerSTOP”);
timer.start();
}

/**
*

Temporizador para executar o stop (se necessario)

*/
public void run()
{
int estado_atual = estado;

if (estado_atual == STAND_BY){
  

  System.out.println("StopServer.timer:  Esperando para iniciar jogo");
  tempo_espera = TIMEOUT_START;

}else{
  
  System.out.println("StopServer.timer:  timer para stop ativado");
  tempo_espera = TIMEOUT_STOP;

}

try {
  Thread.currentThread().sleep(tempo_espera);
} catch (InterruptedException e) {
}

// START
if (estado_atual == STAND_BY  && (jogadores.size() >= 2)){

System.out.println(“StopServer.timer: Iniciando jogo (ja tem 2 jogadores)”);
novoTurno();

  //STOP
}else{ // estado_atual == RUNNING

  System.out.println("StopServer.timer:  Enviando STOP");

  if (estado != STOPED){ // e ainda nao recebeu stop
      stop(null);
  }else{
      System.out.println("StopServer.timer: Alguem ja enviou stop ");
  }
  
}

timer = null;

}

/**

Inicializa um servidor (tambem cria um server registry )

*/
public static void main(String args[])
{
// Security manager
System.setSecurityManager(new RMISecurityManager());

try {
    System.out.println("StopServer.main: creating registry");
    LocateRegistry.createRegistry(1066);
    System.out.println("StopServer.main: creating server");
    StopServerImpl server = new StopServerImpl(1);
    System.out.println("StopServer.main: binding server ");
    Naming.rebind("//:1066/stop.StopServerImpl", server);
    System.out.println("StopServer.main: done");

} catch (Exception e) {
  System.out.println("StopServer.main: an exception occurred: " +
		     e.getMessage());
  e.printStackTrace();
}

}

Nas Férias pretendo fazer um projeto do 0 igual a esse mas de outra forma.

Bem pessoal é isso, se alguém puder ajudar eu agradeço.

system · Dezembro 29, 2015, 2:35am

Jogo Stop_Online em Java

Cursos de Mobile

Cursos de Programação

Cursos de Front-end

Cursos de DevOps

Cursos de Design & UX

Cursos de Business

Cursos de Data & BI