Programación JAVA de juegos de backgammon multiusuario
backgammon en red java
El siguiente código fuente está dividido en 4 archivos
chessClient.java: programa principal del cliente.
chessInterface.java: interfaz del cliente.
chessPad.java: Dibujo de tablero de ajedrez.
chessServer.java: lado del servidor.
Tiene capacidad para 50 personas jugando al ajedrez y charlando online al mismo tiempo.
No se agregan comentarios detallados, pero definitivamente se puede ejecutar. Pasa bajo j2sdk1.4.
/****************************************** ************************************************** * *
1.chessClient.java
***************************** * ************************************************* ** ****************/
importar java.awt.*
importar java.awt.event.*; /p>
importar java.io.*;
importar java.net.*;
importar java.util.*
clase clientThread; extiende el hilo
import java.net.*; p>
{
chessClient chessclient
clientThread(chessClient chessclient)
>{
this.chessclient=chessclient;
}
public void AcceptMessage(String recMessage)
{
if(recMessage.startsWith("/userlist ")) p>
{
StringTokenizer userToken=new StringTokenizer(recMessage, " "); =0;
chessclient.userpad.userList. removeAll();
chessclient.inputpad.userChoice.removeAll();
chessclient.inputpad.userChoice. addItem("Todos");
mientras (userToken.hasMoreTokens())
{
String usuario=(String)userToken.nextToken(" ") ;
if(userNumbert; 0 amp; amp; !user.startsWith("[pulgadas]"))
{
chessclient.userpad.userList. agregar(usuario);
chessclient.inputpad .userChoice.addItem(usuario);
}
número de usuario
}
p>
chessclient.inputpad.userChoice.select("Todas las personas");
}
else if(recMessage.startsWith("/yourname "))
{
chessclient.chessClientName =recMess
age.substring(10);
chessclient.setTitle("Java Gobang Client" "Nombre de usuario:" chessclient.chessClientName
}
else if( recMessage.equals("/reject"))
{
prueba
{
chessclient.chesspad.statusText.setText (" No puedo unirme al juego");
chessclient.controlpad.cancelGameButton.setEnabled(false);
chessclient.controlpad.joinGameButton.setEnabled(true);
chessclient.controlpad.creatGameButton.setEnabled(true);
}
catch(Exception ef)
{
chessclient.chatpad. chatLineArea.setText("chessclient.chesspad.chessSocket.close no se puede cerrar");
}
chessclient.controlpad.joinGameButton.setEnabled(true); >}
else if(recMessage.startsWith("/peer "))
{
chessclient.chesspad.chessPeerName=recMessage.substring(6);
if(chessclient.isServer)
{
chessclient.chesspad.chessColor=1
chessclient.chesspad.isMouseEnabled=true;
chessclient.chesspad.statusText.setText("Por favor, haz un movimiento desde negro");
}
else if(chessclient.isClient)
p>{
chessclient.chesspad.chessColor=-1;
chessclient.chesspad.statusText.setText("Se unió al juego, esperando a la otra parte... ");
}
}
else if(recMessage.equals("/youwin"))
{
chessclient.isOnChess=false;
chessclient.chesspad.chessVictory(chessclient.chesspad.chessColor);
chessclient.chesspad.statusText.setText("La otra parte tiene salió, haga clic en darse por vencido y salga del juego. Conexión");
chessclient.
chesspad.isMouseEnabled=false;
}
else if(recMessage.equals("/OK"))
{
chessclient .chesspad.statusText.setText("El juego se creó correctamente, esperando que otros se unan..."
}
else if(recMessage.equals("/error")); )
{
chessclient.chatpad.chatLineArea.append("Error de transmisión: salga del programa y vuelva a unirse\n");
}
else
{
chessclient.chatpad.chatLineArea.append(recMessage "\n");
chessclient.chatpad.chatLineArea.setCaretPosition(
p>chessclient.chatpad.chatLineArea.getText().length());
}
}
ejecución pública vacía ()
p>
{
Mensaje de cadena=""
prueba
{
mientras(verdadero)
{
message=chessclient.in.readUTF();
acceptMessage(mensaje);
}
catch(IOException es)
{
}
}
}
clase pública chessClient extiende Frame implementa ActionListener, KeyListener
{
userPad userpad=new userPad()
chatPad chatpad; =nuevo chatPad();
controlPad controlpad=nuevo controlPad();
chessPad chesspad=nuevo chessPad()
inputPad inputpad=nuevo inputPad();
Socket chatSocket;
DataInputStream entra;
DataOutputStream sale
Cadena chessClientName=null; String host=null;
int port=4331;
boolean isOnChat=false;
boolean isOnChess=false; //¿Jugando al ajedrez?
boolean isGameConnected=false; // ¿Conexión de cliente para jugar al ajedrez?
booleano esServidor=f
alse; //Si es un anfitrión jugando al ajedrez
boolean isClient=false; //Si es un cliente jugando al ajedrez
Panel surPanel=new Panel(); >
Panel nortePanel=nuevo Panel();
Panel centroPanel=nuevo Panel();
Panel oeste=nuevo Panel(); EastPanel =nuevo Panel();
chessClient()
{
super("Cliente Java Gobang"); nuevo BorderLayout());
host=controlpad.inputIP.getText();
westPanel.setLayout(nuevo
westPanel.add); (userpad, BorderLayout.NORTH);
westPanel.add(chatpad, BorderLayout.CENTER);
westPanel.setBackground(Color.pink); .inputWords.addKeyListener(this);
chesspad.host=controlpad.inputIP.getText();
centerPanel.add(chesspad, BorderLayout.CENTER); p>centerPanel.add(inputpad, BorderLayout.SOUTH);
centerPanel.setBackground(Color.pink);
controlpad.connectButton.addActionListener(this); p>controlpad.creatGameButton.addActionListener(este);
controlpad.joinGameButton.addActionListener(este);
controlpad.cancelGameButton.addActionListener(este); controlpad.exitGameButton.addActionListener(this);
controlpad.creatGameButton.setEnabled(false);
controlpad.joinGameButton.setEnabled(false); cancelGameButton.setEnabled(false);
southPanel.add(controlpad, BorderLayout.CENTER);
southPanel.setBackground(Color.pink);
ner(new WindowAdapter()
{
ventana vacía públicaClosing(WindowEvent e)
{
if(isOnChat)
{
intenta
{
chatSocket.close()
}
captura; (Excepción del artículo)
{
}
}
if(isOnChess || isGameConnected)
{
prueba
{
chesspad.chessSocket.close();
}
catch(Excepción ee )
{
}
}
System.exit(0
}
ventana vacía pública Activada(WindowEvent ea)
{
}
});
add(westPanel, BorderLayout. OESTE);
add(centerPanel, BorderLayout.CENTER);
add(southPanel, BorderLayout.SOUTH);
setSize(670, 548);
setVisible(verdadero);
setResizable(falso);
validar(); p>}
servidor de conexión booleano público (IP del servidor de cadena, puerto del servidor int) arroja una excepción
{
prueba
{
chatSocket=new Socket(serverIP, serverPort);
in=nuevo DataInputStream(chatSocket.getInputStream());
out=nuevo DataOutputStream(chatSocket.getOutputStream());
clientThread clientthread=new clientThread(this);
clientthread.start();
isOnChat=true; ;
}
catch(IOException ex)
{
chatpad.chatLineArea.setText("chessClient: connectServer: No se puede conectar , Se recomienda reiniciar el programa\n");
}
return false;
}
public void actionPerformed( AcciónEvento e)
<p>{
if(e.getSource()==controlpad.connectButton)
{
host=chesspad.host=controlpad.inputIP.getText(
prueba
{
if(connectServer(host,puerto))
{
chatpad); .chatLineArea.setText("");
controlpad.connectButton.setEnabled(false);
controlpad.creatGameButton.setEnabled(true); joinGameButton.setEnabled(true);
chesspad.statusText.setText("Conexión exitosa, crea un juego o únete al juego"); }
catch(Exception ei)
{
chatpad.chatLineArea.setText("controlpad.connectButton: No se puede conectar, se recomienda reiniciar el programa \n");
}
}
if(e.getSource()==controlpad.exitGameButton)
{
if(isOnChat)
{
prueba
{
chatSocket.close(); >
}
catch(Excepción ed)
{
}
}
if( isOnChess || isGameConnected)
{
prueba
{
chesspad.chessSocket.close(); >}
catch(Excepción ee)
{
}
}
System.exit(0 );
}
if(e.getSource()==controlpad.joinGameButton)
{
Cadena seleccionadaUsuario=userpad. userList.getSelectedItem();
if(selectedUser==null || selectedUser.startsWith("[pulgadas]") ||
selectedUser.equals(chessClientName))
{
chesspad.statusText.setText("Primero se debe seleccionar un usuario válido"
}
else
<); p>{prueba
{
if(!isGameConnected)
{
if(chesspad. estafa
nectServer(chesspad.host, chesspad.port))
{
isGameConnected=true
isOnChess=true
isClient= verdadero;
controlpad.creatGameButton.setEnabled(falso);
controlpad.joinGameButton.setEnabled(falso);
controlpad.cancelGameButton.setEnabled(verdadero);
chesspad.chessthread.sendMessage("/joingame " userpad.userList.getSelectedItem() " " chessClientName
}
}
<); p>else{
isOnChess=true;
isClient=true
controlpad.creatGameButton.setEnabled(false); /p>
controlpad.joinGameButton.setEnabled(false);
controlpad.cancelGameButton.setEnabled(true);
chesspad.chessthread.sendMessage("/joingame " panel de usuario. userList.getSelectedItem() " " chessClientName
}
}
catch(Exception ee)
{
isGameConnected=false;
isOnChess=false;
isClient=false;
controlpad.creatGameButton.setEnabled(true); p>controlpad.joinGameButton.setEnabled(true);
controlpad.cancelGameButton.setEnabled(false);
chatpad.chatLineArea.setText("chesspad.connectServer no puede conectarse\n" ee
}
}
}
if(e.getSource()==controlpad.creatGameButton)
{
prueba
{
if(!isGameConnected)
{
if(tablero de ajedrez .connectServer(chesspad.host,chesspad.port))
{
isGameConnected=true
isOnChess=true; =verdadero;
>
controlpad.creatGameButton.setEnabled(false);
controlpad.joinGameButton.setEnabled(false);
controlpad.cancelGameButton.setEnabled(true); p>chesspad.chessthread.sendMessage("/creatgame " "[pulgadas]" chessClientName
}
}
else
{
isOnChess=true;
isServer=true;
controlpad.creatGameButton.setEnabled(false); .setEnabled(false);
controlpad.cancelGameButton.setEnabled(true);
chesspad.chessthread.sendMessage("/creatgame " "[pulgadas]" chessClientName
}
}
catch(Excepción ec)
{
isGameConnected=false
isOnChess=false;
isServer=false;
controlpad.creatGameButton.setEnabled(verdadero);
controlpad.joinGameButton.setEnabled(verdadero); p>
p>
controlpad.cancelGameButton.setEnabled(false);
ec.printStackTrace();
chatpad.chatLineArea.setText("chesspad.connectServer no puede conectar\n" ec );
}
}
if(e.getSource()==controlpad.cancelGameButton)
{
if(isOnChess)
{
chesspad.chessthread.sendMessage("/giveup " chessClientName); (-1*chesspad .chessColor);
controlpad.creatGameButton.setEnabled(verdadero);
controlpad.joinGameButton.setEnabled(verdadero); cancelGameButton.setEnabled(false);
chesspad.statusText.setText("Crea un juego o únete a un juego");
>
}
if(!isOnChess)
{
controlpad.creatGameButton.setEnabled(true);
controlpad. joinGameButton.setEnabled(true);
controlpad.cancelGameButton.setEnabled(false);
chesspad.statusText.setText("Crea un juego o únete al juego"); p>
}
isClient=isServer=false;
}
}
tecla pública vacía presionada (KeyEvent e)
{
TextField inputWords=(TextField)e.getSource();
if(e.getKeyCode()==KeyEvent.VK_ENTER)
{
if(inputpad.userChoice.getSelectedItem().equals("Todos"))
{
prueba
{
out.writeUTF(inputWords.getText());
inputWords.setText("");
}
catch (Excepción ea)
{
chatpad.chatLineArea.setText("chessClient: KeyPressed no puede conectarse, se recomienda volver a conectarse\n"); userpad.userList .removeAll();
inputpad.userChoice.removeAll();
inputWords.setText("");
controlpad.connectButton.setEnabled (verdadero)
}
}
si no
{
inténtalo
{
out.writeUTF("/" inputpad.userChoice.getSelectedItem() " " inputWords.getText());
inputWords.setText(""); >
}
catch(Exception ea)
{
chatpad.chatLineArea.setText("chessClient: KeyPressed no puede conectarse, se recomienda volver a conectarse \n");
userpad.userList.removeAll();
inputpad.userChoice.removeAll();
inputWords.setText("");
controlpad.connectButton.setEnabled(true
}
}
}
<);p>}
clave vacía públicaTyped(KeyEvent e)
{
}
clave vacía públicaReleased(KeyEvent e)
{
}
public static void main(String args[])
{
chessClient chessClient=nuevo chessClient ();
}
}
/************************ ******* ******************************************* ******** *******************
Lo siguiente es: chessInteface.java
** ************** ************************************* *************** ****************************/
importar java.awt.*;
importar java.awt.event.*;
importar java.io.*
importar java.net.*
clase userPad extiende el Panel
{
Lista userList=new List(10);
{
setLayout(nuevo BorderLayout ());
for(int i=0;ilt;50;i)
{
userList.add(i "." "Sin usuario ");
}
add(userList, BorderLayout.CENTER);
}
clase chatPad extiende el Panel
{
TextArea chatLineArea=new TextArea("", 18, 30, TextArea.SCROLLBARS_VERTICAL_ONLY );
chatPad()
{
setLayout(nuevo BorderLayout()
add(chatLineArea, BorderLayout.CENTER)
}
}
clase controlPad extiende el Panel
{
Etiqueta IPlabel=nueva Etiqueta(" IP", Label.LEFT);
TextField inputIP=new TextField("localhost", 10);
Botón connectButton=new Button("Conectar al host"); p>
Botón creatGameButton=nuevo Botón("Crear juego")
Botón joinGam;
eButton=new Button("Unirse al juego");
Botón cancelGameButton=new Button("Abandonar juego");
Botón exitGameButton=new Button("Cerrar programa");
controlPad()
{
setLayout(new FlowLayout(FlowLayout.LEFT));
setBackground(Color.pink)
add(IPlabel);
add(inputIP);
add(connectButton);
add(creatGameButton); /p >
add(unirseGameButton);
add(cancelGameButton);
add(exitGameButton);
}
}
la clase inputPad extiende el Panel
{
TextField inputWords=new TextField("", 40
Elección userChoice=new); Elección( );
inputPad()
{
setLayout(new FlowLayout(FlowLayout.LEFT)); i= 0; ilt; 50; i )
{
userChoice.addItem(i "." "Sin usuario"); >
userChoice.setSize(60, 24);
add(userChoice);
add(inputWords
}
<); p> }/*************************************** *** ************************************************* **** ***
Lo siguiente es: chessPad.java
************************ ****** ********************************************** ******* *******************/
importar java.awt.*
importar java. .awt.event.*;
importar java.awt.event.*;
importar java.awt.event.*; p>
importar java.io.*
importar java.net.*;
importar java.util.*;
clase chessThread extiende el hilo
{ p>
tablero de ajedrez;
chessThread(tablero de ajedrez)
{
this.chesspad= tablero de ajedrez
}
envío vacío público
ssage(String sndMessage)
{
prueba
{
chesspad.outData.writeUTF(sndMessage); p>}
catch(Excepción ea)
{
System.out.println("chessThread.sendMessage: "
<); p>}}
public void aceptarMessage(String recMessage)
{
if(recMessage.startsWith("/chess " ))
{
StringTokenizer userToken=new StringTokenizer(recMessage, " ");
String chessToken
String[] chessOpt; ={"-1", "-1", "0"};
int chessOptNum=0
mientras(userToken.hasMoreTokens())
{
chessToken=(String)userToken.nextToken(" ");
if(chessOptNumgt;=1 amp; amp; chessOptNumlt;=3)
{
ajedrezOpt[chessOptNum-1]=chessToken;
}
ajedrezOptNum
}
chesspad.netChessPaint(Integer.parseInt(chessOpt[0]), Integer.parseInt(chessOpt[1]), Integer.parseInt(chessOpt[2]));
}
else if(recMessage.startsWith("/yourname "))
{
chesspad.chessSelfName=recMessage.substring(10);
}
else if(recMessage.equals("/error"))
{
chesspad.statusText.setText("Error: no existe tal usuario, salga del programa e intente nuevamente Agregar");
}
else
{
//System.out.println(recMessage);
}
}
public void run()
{
String message=""; /p>
intenta
{
mientras(verdadero)
{
message=chesspad.inData.readUTF() ;
aceptarMensaje(mensaje
}
<);p>}
catch(IOException es)
{
}
}
}
la clase chessPad extiende el Panel implementa MouseListener, ActionListener
{
int chessPoint_x=-1, chessPoint_y=-1, chessColor=1
int; chessBlack_x[]=nuevo int[200];
int chessBlack_y[]=nuevo int[200];
int chessWhite_x[]=nuevo int[200];
int chessWhite_y[]=new int[200];
int chessBlackCount=0, chessWhiteCount=0
int chessBlackWin=0, chessWhiteWin=0;
boolean isMouseEnabled=false, isWin=false, isInGame=false;
TextField statusText=new TextField("Primero conéctese al servidor");
Socket chessSocket; /p >
DataInputStream inData
DataOutputStream outData;
Cadena chessSelfName=null
Cadena chessPeerName=null; String host =null;
int port=4331
chessThread chessthread=new chessThread(this
chessPad()
{
setSize(440, 440);
setLayout(null);
setBackground(Color.pink);
addMouseListener( esto)
add(statusText);
statusText.setBounds(40, 5, 360, 24);
statusText.setEditable(false); /p >
}
connectServer público booleano (String ServerIP, int ServerPort) arroja una excepción
{
prueba
{ p>
chessSocket=nuevo Socket(ServerIP, ServerPort);
inData=nuevo DataInputStream(chessSocket.getInputStream());
outData=nuevo DataOutputStream(chessSocket. getOutputStream());
>chessthread.start();
devuelve verdadero;
}
catch(IOException ex)
{
statusText.setText("chessPad: connectServer: No se puede conectar\n");
}
return false
}
public void chessVictory(int chessColorWin)
{
this.removeAll()
for(int i=0; ilt; =chessBlackCount; i )
{
ajedrezNegro_x[i]=0
ajedrezNegro_y[i]=0
}
<; p >for(int i=0;ilt;=chessWhiteCount;i){
ajedrezBlanco_x[i]=0
ajedrezBlanco_y[i]= 0 ;
}
ajedrezBlackCount=0
ajedrezWhiteCount=0
add(statusText
statusText.setBounds(40, 5, 360, 24);
if(chessColorWin==1)
{ chessBlackWin
statusText.setText(" negro El ajedrez gana, negro: blanco es "chessBlackWin": "chessWhiteWin", reinicia el juego, espera el movimiento de las blancas...");
}
else if(chessColorWin ==- 1)
{
chessWhiteWin;
statusText.setText("Las blancas ganan, las negras: las blancas son "chessBlackWin": "chessWhiteWin", reiniciar , Esperando a que las negras hagan un movimiento...");
}
}
public void getLocation(int a, int b, int color)
{
if(color==1)
{
chessBlack_x[chessBlackCount]=a*20
;chessBlack_y [chessBlackCount]=b*20
ajedrezBlackCount
}
else if(color==-1)
{
ajedrezWhite_x[chessWhiteCount]=a*20
ajedrezWhite_y[chessWhiteCount]=b*20
ajedrezWhiteCount
}
chessWhite_y[chessWhiteCount]=b*20; p>
}
checkWin booleano público(int a, int b, int checkColor)
{
>int paso=1, chessLink=1, chessLinkTest=1, chessCompare=0
if(checkColor==1)
{
chessLink=1;
for(paso=1; pasolt; =4; paso )
{
for(chessCompare=0; chessComparelt; =chessBlackCount; chessCompare )
{
if(((un paso)*20==chessBlack_x[chessCompare]) amp; amp; ((b*20)==chessBlack_y[chessCompare])) p>
{
chessLink=ajedrezEnlace 1;
if(chessLink==5)
{
return(true)
}
}
}
if(chessLink==(chessLinkTest 1))
chessLinkTest;
else
romper;
}
for(paso=1; steplt;=4; paso)
{
for(chessCompare=0;chessComparelt;=chessBlackCount;chessCompare)
{
if(((un paso)*20 ==chessBlack_x[chessCompare]) amp; (b*20==chessBlack_y[chessCompare]))
{
ajedrezLink
if(chessLink; ==5)
{
return(verdadero
}
}
} p>
if(chessLink==(chessLinkTest 1))
chessLinkTest;
else
romper; /p>
chessLink=1;
chessLinkTest=1;
for(paso=1; pasolt; =4; paso )
{
for(chessCompare=0;chessComparelt;=chessBlackCount;chessCompare)
{
if((a*20==chessBlack_x[chessCompare]) amp; amp ; ((b paso)*20==chessBlack_y[chessCompare]))
{
chessLink
if(chessLink==5)
{
return(verdadero
}
}
}
si( enlaceajedrez==(enlaceajedrez
Prueba 1))
chessLinkTest
else
romper
}
for(paso=1) ; pasolt;=4; paso )
{
for(chessCompare=0;chessComparelt;=chessBlackCount;chessCompare)
{
if((a*20==chessBlack_x[chessCompare]) amp; amp; ((b-step)*20==chessBlack_y[chessCompare]))
{
chessLink
if(chessLink==5)
{
return(true
}
}
}
if(chessLink==(chessLinkTest 1))
chessLinkPrueba
else
romper;
}
chessLink=1;
chessLinkTest=1
for(paso=1; steplt;=4; paso )
{
for(chessCompare=0;chessComparelt;=chessBlackCount;chessCompare)
{
if(((a -paso)*20==chessBlack_x[chessCompare]) amp; ((b paso)*20==chessBlack_y[chessCompare]))
{
ajedrezEnlace p> p>
if(chessLink==5)
{
return(true);
}
}
p>
}
if(chessLink==(chessLinkTest 1))
chessLinkTest
else
romper;
}
para(paso=1; pasolt; =4; paso )
{
para (chessCompare=0; chessComparelt; =chessBlackCount;chessCompare)
{
if(((un paso)*20==chessBlack_x[chessCompare]) amp;amp; ((b -paso)*20== chessBlack_y[chessCompare]))
{
ajedrezEnlace
if(chessLink==5)
{
return(true);
}
}
}
if(chessLink== (pruebaEnlaceAjedrez 1))
PruebaEnlaceAjedrez
else
romper;
}
chessLink=1;
chessLinkTest=1; =1; pasolt; =4; paso )
{
for(chessCompare=0; chessComparelt; =chessBlackCount; chessCompare )
{
if(((un paso)*20==chessBlack_x[chessCompare]) amp; amp; ((b paso)*20==chessBlack_y[chessCompare]))
{
Enlace de ajedrez
if(Enlace de ajedrez==5)
{
retorno(verdadero
}
}
}
if(chessLink==(chessLinkTest 1))
chessLinkTest
else
romper;
}
para(paso=1; pasolt;=4; paso)
{
para (chessCompare=0;chessComparelt;=chessBlackCount;chessCompare)
{
if(((un paso)*20==chessBlack_x[chessCompare]) amp;amp; (( paso b)*20==chessBlack_y[chessCompare]))
{
chessLink
if(chessLink==5)
{
return(verdadero);
}
}