[code]
import java.awt.BorderLayout;
import java.net.ServerSocket;
import java.net.Socket;
import java.io.IOException;
import java.util.Formatter;
import java.util.Scanner;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.Condition;
import javax.swing.JFrame;
import javax.swing.JTextArea;
import javax.swing.SwingUtilities;
public class Servidor extends JFrame
{
private JTextArea outputArea; // para gerar saída das jogadas
private Player[] players; // array de Players
private ServerSocket server; // socket de servidor para conectar com clientes
private int currentPlayer; // monitora o jogador com a jogada atual
private final static int PLAYER_1 = 0; // constante para o primeiro jogador
private final static int PLAYER_2 = 1; // constante para o segundo jogador
private final static String[] MARKS = { “0”, “1” }; // array de marcas
private ExecutorService runGame; // executará os jogadores
private Lock gameLock; // para bloquear a sincronização do jogo
private Condition otherPlayerConnected; // para esperar outro jogador
//private Condition otherPlayerTurn; // para esperar a jogada do outro jogador
int I=0; String valor;String aux; boolean GameOver = true;
// configura o servidor de tic-tac-toe e a GUI que exibe as mensagens
public Servidor()
{
super( “Game Server” ); // configura o título da janela
// cria ExecutorService com uma thread para cada jogador
runGame = Executors.newFixedThreadPool( 2 );
gameLock = new ReentrantLock(); // cria um bloqueio para o jogo
// variável de condição para os dois jogadores sendo conectados
otherPlayerConnected = gameLock.newCondition();
// variável de condição para a jogada do outro jogador
// otherPlayerTurn = gameLock.newCondition();
players = new Player[ 2 ]; // cria array de jogadores
currentPlayer = PLAYER_1; // configura o jogador atual como o primeiro jogador
try
{
server = new ServerSocket( 12345, 2 ); // configura ServerSocket
} // fim do try
catch ( IOException ioException )
{
ioException.printStackTrace();
System.exit( 1 );
} // fim do catch
outputArea = new JTextArea(); // cria JTextArea para saída
add( outputArea, BorderLayout.CENTER );
outputArea.setText( "Server awaiting connections\n" );
setSize( 300, 300 ); // configura o tamanho da janela
setVisible( true ); // mostra a janela
int num = (int) (Math.random() * 10);
valor = String.valueOf(num);
System.out.println("\nvalornoservidor="+valor);
} // fim do construtor TicTacToeServer
// espera duas conexões para que o jogo possa ser jogado
public void execute()
{
// espera que cada cliente se conecte
for ( I = 0; I < players.length; I++ )
{
try // espera a conexão, cria Player, inicia o executável
{
players[ I ] = new Player( server.accept(), I, this );
runGame.execute( players[ I ] ); // executa o executável de jogador
System.out.println(" i="+I);
} // fim do try
catch ( IOException ioException )
{
ioException.printStackTrace();
System.exit( 1 );
} // fim do catch
} // fim do for
//returnvalor();
gameLock.lock(); // bloqueia o jogo para sinalizar a thread do jogador X
try
{
players[ PLAYER_1 ].setSuspended( false ); // retoma o jogador X
otherPlayerConnected.signal(); // acorda a thread do jogador X
} // fim do try
finally
{
gameLock.unlock(); // desbloqueia o jogo depois de sinalizar para o jogador X
} // fim de finally
System.out.println(" dps for i="+I);
} // fim do método execute
/* public void returnvalor(){
Player ch = new Player(null, I);
int j =I;
ch.pegavalor(j);
System.out.println("j="+j);
}*/
// exibe uma mensagem na outputArea
private void displayMessage( final String messageToDisplay )
{
// exibe uma mensagem a partir da thread de despacho de eventos da execução
SwingUtilities.invokeLater(
new Runnable()
{
public void run() // atualiza a outputArea
{
outputArea.append( messageToDisplay ); // adiciona mensagem
} // fim do método run
} // fim da classe inner
); // fim da chamada para SwingUtilities.invokeLater
} // fim do método displayMessage
// classe interna privada Player gerencia cada Player como um executável
private class Player implements Runnable
{
private Socket connection; // conexão com o cliente
private Scanner input; // entrada do cliente
private Formatter output; // saída para o cliente
private int playerNumber; // monitora qual jogador isso é
private int mark; // marca para esse jogador
private boolean suspended = true; // se a thread está suspensa
int resp=-1;
/*public void pegavalor(int j){
int i=j;
System.out.println("return i"+i);
}*/
// configura a thread Player
public Player( Socket socket, int number, Servidor s )
{
playerNumber = number; // armazena o número desse jogador
connection = socket; // armazena o socket para o cliente
try // obtém fluxos a partir de Socket
{
input = new Scanner( connection.getInputStream() );
output = new Formatter( connection.getOutputStream() );
} // fim do try
catch ( IOException ioException )
{
ioException.printStackTrace();
System.exit( 1 );
} // fim do catch
} // fim do construtor Player
public void doisjogadores(){
output.format(valor);
output.format(" \n");
output.format(" jogadores 2");
}
// execução da thread de controle
public void run()
{
try
{
displayMessage( "Player " + mark + " connected\n" );
//output.format( "%s\n", mark ); // envia a marca do jogador
output.flush(); // esvazia a saída
// se for o jogador X, espera que o outro jogador chegue
if ( playerNumber == PLAYER_1 )
{
output.format( "%s\n%s", "Player 1 connected",
"Waiting for another player\n" );
output.flush(); // esvazia a saída
gameLock.lock(); // bloqueia o jogo para esperar o segundo jogador
try
{
while( suspended )
{
otherPlayerConnected.await(); // espera o jogador O
} // fim do while
} // fim de try
catch ( InterruptedException exception )
{
exception.printStackTrace();
} // fim do catch
finally
{
gameLock.unlock(); // desbloqueia o jogo depois do segundo jogador
} // fim de finally
System.out.println("antes i"+I);
if (I==2){
System.out.println("entrou if");
doisjogadores();
}
// envia uma mensagem de que o outro jogador se conectou
/* System.out.println("\nantes inputhasnext\n");
if ( input.hasNext() )
{ System.out.println("\ndentro inputhasnext\n");
resp = input.nextInt(); // obtém a posição da jogada
if (resp==2)
{ System.out.println("\nACERTEI \n");}}*/
output.flush(); // esvazia a saída
} // fim do if
else
{
output.format( "Player 2 connected, please wait\n" );
doisjogadores();
output.flush(); // esvazia a saída
} // fim de else
// if ( input.hasNext() )
// System.out.println( "inputnext="+input.next()); // obtém a posição da jogada
while ( true )
{
int location = 0; // inicializa a posição da jogada
System.out.println("antes input.next()");
if ( input.hasNext() )
{
System.out.println("input.next()");
location = input.nextInt(); // obtém a posição da jogada
displayMessage( "\nlocation: " + location );
System.out.println("location:"+location);
}
}
} // fim do try
finally
{
try
{
connection.close(); // fecha a conexão com o cliente
} // fim do try
catch ( IOException ioException )
{
ioException.printStackTrace();
System.exit( 1 );
} // fim do catch
} // fim de finally
} // fim do método run
// configura se a thread está ou não suspensa
public void setSuspended( boolean status )
{
suspended = status; // configura o valor do suspenso
} // fim do método setSuspended
} // fim da classe Player
public static void main( String args[] )
{
Servidor application = new Servidor();
application.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
application.execute();
} // fim de main
} // fim da classe TicTacToeServer[/code]
[code]
import java.awt.*;
import java.net.Socket;
import java.net.InetAddress;
import java.io.IOException;
import javax.swing.*;
import java.util.Formatter;
import java.util.Scanner;
import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;
public class JogoCliente extends JFrame implements Runnable
{
private Socket connection; // conexão com o servidor
private Scanner input; // entrada a partir dprimeiroo servidor
private Formatter output; // saída para o servidor
private String ticTacToeHost; // nome do host para o servidor
private String myMark; // marca desse cliente
private boolean myTurn; // determina de qual cliente é a vez
private final String MARK_1 = “1”; // marca para o primeiro cliente
private final String MARK_2 = “2”; // marca para o segundo cliente
//label
private JLabel tempo = new JLabel(“Tempo”);
private JLabel nome = new JLabel(“Nome”);
private JLabel nome2 = new JLabel(“Nome2”);
private JLabel pontos = new JLabel(“Pontos”);
private JLabel pontos2 = new JLabel(“Pontos2”);
private JLabel pergunta = new JLabel(“Pergunta”);
//string
String alt_a = “alternativa a”;
String alt_b = “alternativa b”;
String alt_c = “alternativa c”;
String alt_d = “alternativa d”;
String nomejog;
//radiobutton
JRadioButton rbutton_a = new JRadioButton(alt_a);
JRadioButton rbutton_b = new JRadioButton(alt_b);
JRadioButton rbutton_c = new JRadioButton(alt_c);
JRadioButton rbutton_d = new JRadioButton(alt_d);
JTextArea txtarea = new JTextArea(10,10);
int cont=0,num=-1,seila=-1;
int resp;
// configura a interface com o usuário e o tabuleiro
public JogoCliente( )
{
ticTacToeHost = “127.0.0.1”; // configura o nome do servidor
GridBagConstraints cons = new GridBagConstraints();
JPanel panel = new JPanel();
cons.ipady=10;
cons.ipadx=10;
panel.setLayout(new GridBagLayout());
cons.fill = GridBagConstraints.NONE;
//tempo
cons. gridwidth=5;
cons.insets = new Insets(100,-40,0,0);
cons.gridx = 1; cons.gridy = 0;
panel.add(tempo, cons);
cons. gridwidth=1;
cons.insets = new Insets(0,0,0,0);
//jogador1
cons.gridx = 0; cons.gridy = 1;
panel.add(nome, cons);
cons.gridx = 0; cons.gridy = 2;
panel.add(pontos, cons);
//pergunta
cons.insets = new Insets(0,20,0,20);
cons. gridwidth=3;
cons.gridx = 1; cons.gridy = 1;
panel.add(pergunta, cons);
//respostas
ButtonGroup group = new ButtonGroup();
cons.gridx = 1; cons.gridy = 3;
panel.add(rbutton_a, cons);
group.add(rbutton_a);
cons.gridx = 1; cons.gridy = 4;
panel.add(rbutton_b, cons);
group.add(rbutton_b);
cons.gridx = 1; cons.gridy = 5;
group.add(rbutton_c);
panel.add(rbutton_c, cons);
cons.gridx = 1; cons.gridy = 6;
panel.add(rbutton_d, cons);
group.add(rbutton_d);
cons. gridheight=1;
cons. gridwidth=1;
cons.insets = new Insets(0,0,0,0);
//jogador 2
cons.gridx = 5; cons.gridy = 1;
panel.add(nome2, cons);
cons.gridx = 5; cons.gridy = 2;
panel.add(pontos2, cons);
setLayout(new BorderLayout());
add("North", panel);
add("South", txtarea);
tempo.setFont(new Font("Courier", Font.BOLD, 16));
tempo.setForeground(Color.RED);
pontos.setForeground(Color.RED);
pontos2.setForeground(Color.RED);
setSize( 600, 600 );
//pack();
setVisible(true);
startClient();
} // fim do construtor TicTacToeClient
public void m() {
//nomejog=JOptionPane.showInputDialog(null, "digite um nome");
//nome.setText(nomejog);
if (num !=-1)
random();
}
public void random() {
String perg;
// int num = (int) (Math.random() * 10);
System.out.println("random"+num);
switch (0) {
case 0: {
perg="De quantos anos é constituído um século?1";
pergunta.setText(perg);
rbutton_a.setText("50");
rbutton_b.setText("100");
rbutton_c.setText("1000");
rbutton_d.setText("1500");
resp =2;
break;}
case 1: {
perg="Qual é o coletivo de cães?";
pergunta.setText(perg);
rbutton_a.setText("MATILHA");
rbutton_b.setText("REBANHO");
rbutton_c.setText("CARDUME");
rbutton_d.setText("MANADA");
resp =1;
//output.format( resp );
//output.flush();
break;}
case 2: {
perg=" Qual é o naipe do baralho que tem o desenho de coração?";
pergunta.setText(perg);
rbutton_a.setText("OUROS");
rbutton_b.setText("PAUS");
rbutton_c.setText("COPAS");
rbutton_d.setText("ESPADAS");
resp =3;
//output.format( resp );
//output.flush();
break;}
case 3: {
perg="Qual casal foi expulso do Paraíso?";
pergunta.setText(perg);
rbutton_a.setText("SANSÃO E DALILA");
rbutton_b.setText("JOSÉ E MARIA");
rbutton_c.setText("SARA E ABRAÃO");
rbutton_d.setText("ADÃO E EVA");
resp =4;
//output.format( resp );
//output.flush();
break;}
case 4: {
perg="Segundo os contos, qual animal ao ser beijado se transformaem príncipe?";
pergunta.setText(perg);
rbutton_a.setText("CAVALO");
rbutton_b.setText("CÃO");
rbutton_c.setText("GATO");
rbutton_d.setText("SAPO");
resp =4;
//output.format( resp );
//output.flush();
break;}
case 5: {
perg=" Em qual parte do corpo humanosão implantadas as ?pontes desafena??";
pergunta.setText(perg);
rbutton_a.setText("ESTÔMAGO");
rbutton_b.setText("INTESTINO");
rbutton_c.setText("PULMÃO");
rbutton_d.setText("CORAÇÃO");
resp =4;
//output.format(resp);
//output.flush();
break;}
case 6: {
perg=" Na literatura, quem foi ocriador da boneca Emília?";
pergunta.setText(perg);
rbutton_a.setText("MONTEIRO LOBATO");
rbutton_b.setText("MAURÍCIO DE SOUZA");
rbutton_c.setText("WALT DISNEY");
rbutton_d.setText("JORGE AMADO");
resp =1;
//output.format( resp );
//output.flush();
break;}
case 7: {
perg="Quem é o primeiro substitutodo Presidente?";
pergunta.setText(perg);
rbutton_a.setText("VEREADOR");
rbutton_b.setText("VICE-PRESIDENTE");
rbutton_c.setText("SENADOR");
rbutton_d.setText("DEPUTADO");
resp =2;
//output.format( resp );
//output.flush();
break;}
case 8: {
perg="Em qual cidade está o CristoRedentor do Corcovado?";
pergunta.setText(perg);
rbutton_a.setText("RIO DE JANEIRO");
rbutton_b.setText("SÃO PAULO");
rbutton_c.setText("CURITIBA");
rbutton_d.setText("BELO HORIZONTE");
resp =1;
//output.format( resp );
//output.flush();
break;}
case 9: {
perg=" Quantos centímetros equivalema um metro?";
pergunta.setText(perg);
rbutton_a.setText("10");
rbutton_b.setText("100");
rbutton_c.setText("1000");
rbutton_d.setText("10000");
resp =2;
//output.format( resp );
//output.flush();
break;}
}
cont++;
passaresposta(resp);
if (cont!=5)
random();
else
{
// random_medio();
}
}
private void passaresposta(int resp2) {
output.format( "%d\n", resp2 ); // envia a resposta ao servidor
output.flush();
}
// inicia a thread do cliente
public void startClient()
{
try // conecta-se ao servidor, obtém os fluxos e inicia o outputThread
{
// faz uma conexão com o servidor
connection = new Socket(
InetAddress.getByName( ticTacToeHost ), 12345 );
// obtém os fluxos de entrada e saída
input = new Scanner( connection.getInputStream() );
output = new Formatter( connection.getOutputStream() );
} // fim do try
catch ( IOException ioException )
{
ioException.printStackTrace();
} // fim do catch
// cria e inicia a thread de trabalhador para esse cliente
ExecutorService worker = Executors.newFixedThreadPool( 1 );
worker.execute( this ); // executa o cliente
} // fim do método startClient
// thread de controle que permite atualização contínua da displayArea
public void run()
{
//myMark = input.nextLine(); // obtém a marca do jogador (X ou O)
SwingUtilities.invokeLater(
new Runnable()
{
public void run()
{
// exibe a marca do jogador
txtarea.setText( "You are player \"" + myMark + "\"" );
} // fim do método run
} // fim da classe interna anônima
); // fim da chamada para SwingUtilities.invokeLater
// recebe as mensagens enviadas para o cliente e gera saída delas
while ( true )
{
if ( input.hasNextLine() )
processMessage(input.nextLine());
} // fim do while
} // fim do método run
// processa as mensagens recebidas pelo cliente
private void processMessage( String message )
{ int aux=0; char[] b = null;
char[] c = message.toCharArray();
for ( int i = 0; i <=0; i++ )
// verifica se o char não é um dígito
if ( Character.isDigit( c[ i ] ) ) {
seila= Integer.parseInt( Character.toString((char) c[i]));
System.out.println("c= "+c[i]);
System.out.println("seila= "+seila);
// num=seila;
}
System.out.println("\n message= "+message);
if ( message.equals(" jogadores 2") )
{
num=seila;
m();
System.out.println("entrou");
} // fim do if
else if ( message.equals( "Invalid move, try again" ) )
{
displayMessage( message + "\n" ); // exibe jogada inválida
myTurn = true; // ainda é a vez desse cliente
} // fim de else if
else if ( message.equals( "Opponent moved" ) )
{
int location = input.nextInt(); // obtém a posição da jogada
input.nextLine(); // pula uma nova linha depois da posição de int
displayMessage( "Opponent moved. Your turn.\n" );
myTurn = true; // agora é a vez desse cliente
} // fim de else if
else
displayMessage( message + " \n" ); // exibe a mensagem
} // fim do método processMessage
// manipula outputArea na thread de despacho de eventos
private void displayMessage( final String messageToDisplay )
{
SwingUtilities.invokeLater(
new Runnable()
{
public void run()
{
txtarea.append( messageToDisplay ); // atualiza a saída
} // fim do método run
} // fim da classe inner
); // fim da chamada para SwingUtilities.invokeLater
} // fim do método displayMessage
public static void main( String args[] )
{
JogoCliente application; // declara o aplicativo cliente
// se não houver nenhum argumento de linha de comando
application = new JogoCliente( ); // host local
application.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
} // fim de main
} [/code]