Red de conocimiento informático - Material del sitio web - Programación JAVA de juegos de backgammon multiusuario

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 "))

{

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");

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

{

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

{

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]))

{

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

}

}

}

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>

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);

}

}