Estoy buscando urgentemente código de backgammon Java. . . Debe ser absolutamente original (puede obtener puntos extra)
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.*
importar java.io.*;
importar java.net.*
importar java.util.*; clase clientThread extiende Thread
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," "
int número de usuario=0;
chessclient.userpad.userList.
chessclient.inputpad.userChoice.removeAll(); >chessclient.inputpad.userChoice.addItem("Todos");
mientras (userToken.hasMoreTokens())
{
String usuario=(String) userToken.nextToken(" ");
if(userNumber>0 && ! user.startsWith("[pulgadas]"))
{
chessclient. userpad.userList.add(usuario);
chessclient.inputpad.userChoice. addItem(usuario);
}
userNumber++; >}
chessclient.inputpad.userChoice.select("Todos")
}
else if(recMessage.startsWith("/tunombre "))
{
chessclient.chessClientName=recMessage. substring(10);
chessclient.setTitle("Java Gomoku Client"+"Nombre de usuario:"+chessclient. ajedrezClienteNombre);
}
else if(recMessage.equals("/reject"))
{
intenta
{
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)
p>
{
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 con las negras"); /p>
}
p>
else if(chessclient.isClient)
{
chessclient.chesspad.chessColor=-1;
chessclient.chesspad.statusText.setText ("Ya me uní al juego, esperando a la otra parte..."); p>
else if(recMessage.equals("/youwin") )
{
chessclient.isOnChess=false;
chessclient.chesspad. chessVictory(chessclient.chesspad.chessColor);
chessclient .chesspad.statusText.setText("La otra parte ha salido, haga clic en Cancelar el juego para salir de la 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...");
ls("/error"))
{
chessclient.chatpad.chatLineArea.append("Error de transmisión: salga del programa y vuelva a unirse\n");
}
else
{
chessclient.chatpad.chatLineArea.append(recMessage+"\n"); .chatpad.chatLineArea.setCaretPosition(
chessclient.chatpad.chatLineArea.getText().length()
}
}
<); p>public void run(){
String message=""
prueba
{
{
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();
ajedrezPad chesspad=nuevo ajedrezPad()
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?
boolean isServer=false; //Si es un host jugando al ajedrez
boolean isClient=false //Si es un cliente jugando al ajedrez
Panel Panel sur =nuevo Panel();
Panel nortePanel=nuevo Panel();
Panel centroPanel=nuevo Panel()
Panel oestePanel=nuevo Panel( ) ;
Panel estePanel=nuevo Panel();
chessClient()
{
super("Cliente Java Gobang)
end");
setLayout(nuevo BorderLayout());
host=controlpad.inputIP.getText();
westPanel.setLayout(nuevo BorderLayout( ));
westPanel.add(userpad,BorderLayout.NORTH);
westPanel.add(chatpad,BorderLayout.CENTER); Color.pink);
inputpad.inputWords.addKeyListener(this);
chesspad.host=controlpad.inputIP.getText();
centerPanel.add); (tablero de ajedrez,BorderLayout.CENTER);
centerPanel.add(inputpad,BorderLayout.SOUTH);
centerPanel.setBackground(Color.pink); .connectButton.addActionListener(este);
controlpad.creatGameButton.addActionListener(este);
controlpad.joinGameButton.addActionListener(este); .addActionListener(este);
controlpad.exitGameButton.addActionListener(este);
controlpad.creatGameButton.setEnabled(false);
controlpad.joinGameButton.setEnabled (falso);
controlpad.cancelGameButton.setEnabled(falso);
southPanel.add(controlpad,BorderLayout.CENTER
southPanel.setBackground(Color); .pink);
addWindowListener(new WindowAdapter()
{
cierre de ventana pública vacía (WindowEvent e)
{
if(isOnChat)
{
prueba
{
chatSocket.close()
<; p>}catch(Excepción ed)
{
}
}
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.WEST);
add(centerPanel,BorderLayout.CENTER); >add(southPanel,BorderLayout.SOUTH);
paquete();
setSize(670,548);
setVisible(true); p>setResizable(false);
validate();
}
connectServer booleano público (String serverIP,int serverPort) arroja una excepción
{
prueba
{
chatSocket=new Socket(serverIP,serverPort
in=new DataInputStream(chatSocket. getInputStream());
out=new DataOutputStream(chatSocket.getOutputStream());
clientThread clientthread=new clientThread(this); ();
isOnChat=true;
devuelve verdadero
}
catch(IOException ex)
{
chatpad.chatLineArea.setText("chessClient:connectServer: No se puede conectar, se recomienda reiniciar el programa\n");
}
return false;
}
acción nula pública realizada (ActionEvent e)
{
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);
controlpad.joinGameButton.setEnabled(true);
chesspad.statusText.setText ("Conexión exitosa, crea un juego o únete a un juego"
}
}
catch(Exception ei)
{
c
hatpad.chatLineArea.setText("controlpad.connectButton: No se puede conectar, se recomienda reiniciar el programa\n"); if(e. getSource()==controlpad.exitGameButton)
{
if(isOnChat)
{
intentar
{
chatSocket.close();
}
catch(Excepción ed)
{
}
}
if(isOnChess || isGameConnected)
{
probar
{
chesspad.chessSocket.close();
}
catch(Excepción ee)
{
}
p>
}
System.exit(0);
}
if(e.getSource( )==controlpad.joinGameButton)
{
String selectedUser=userpad.userList.getSelectedItem();
if(selectedUser==null || usuario seleccionado. comienza con ("[pulgadas]") |
selectedUser.equals(chessClientName))
{
chesspad.statusText.setText("Un usuario válido debe seleccionarse primero");
}
else
{
probar
{
if(!isGameConnected)
{
if(chesspad.connectServer(chesspad.host,chesspad.port))
{
isGameConnected=true;
p>
isOnChess=true;
isClient=true
controlpad.creatGameButton.setEnabled(falso);
controlpad.joinGameButton.setEnabled(false );
controlpad.cancelGameButton.setEnabled(true);
chesspad.chessthread.sendMessage("/joingame "+ userpad.userList.getSelectedItem()+" "+chessClientName
}
}
else
{
isOnChess=true;
isClient=true;
controlpad.creatGameButton.setEnabled(false);
controlpad.joinGameButton.setEnabled(false);
controlpa
d.cancelGameButton.setEnabled(true);
chesspad.chessthread.sendMessage("/joingame "+userpad.userList.getSelectedItem()+" "+chessClientName
}
}
catch(Excepción ee)
{
isGameConnected=false
isOnChess=false; /p>
isClient=false;
controlpad.creatGameButton.setEnabled(true);
controlpad.joinGameButton.setEnabled(true); .cancelGameButton.setEnabled(false);
chatpad.chatLineArea.setText("chesspad.connectServer no puede conectarse\n"+ee
}
}
}
if(e.getSource()==controlpad.creatGameButton)
{
prueba
{
if(!isGameConnected)
{
if(chesspad.connectServer(chesspad.host,chesspad.port))
{
isGameConnected=true;
isOnChess=true;
isServer=true
controlpad.creatGameButton.setEnabled(falso)
controlpad.joinGameButton.setEnabled(false);
controlpad.cancelGameButton.setEnabled(true);
chesspad.chessthread.sendMessage("/creatgame "); +"[pulgadas]"+chessClientName);
}
}
else
{
isOnChess =true;
isServer=true;
controlpad.creatGameButton.setEnabled(false);
controlpad.joinGameButton.setEnabled(false);
controlpad.cancelGameButton.setEnabled(true);
chesspad.chessthread.sendMessage("/creatgame "+"[pulgadas]"+chessClientName
}
}
catch(Excepción ec)
{
isGameConnected=false
isOnChess=false; >
isServer=falso;
/p>
controlpad.creatGameButton.setEnabled(true);
controlpad.joinGameButton.setEnabled(true);
controlpad.cancelGameButton.setEnabled(false); >
ec.printStackTrace();
chatpad.chatLineArea.setText("chesspad.connectServer no puede conectarse\n"+ec
}
if(e.getSource()==controlpad.cancelGameButton)
{
if(isOnChess)
{
chesspad.chessthread.sendMessage("/giveup "+chessClientName);
chesspad.chessVictory(-1*chesspad.chessColor);
controlpad.creatGameButton. setEnabled(verdadero);
controlpad.joinGameButton.setEnabled(verdadero);
controlpad.cancelGameButton.setEnabled(falso); "Por favor, crea un juego o únete a un juego");
}
if(!isOnChess)
{
controlpad.creatGameButton. .setEnabled (verdadero);
controlpad.joinGameButton.setEnabled(verdadero);
controlpad.cancelGameButton.setEnabled(falso); (" Crea un juego o únete a un juego ");
}
isClient=isServer=false
}
}
tecla public voidPressed(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(Exception ea)
{
chatpad.chatLineArea.setText("chessClient:KeyPressed no puede conectarse, es recomendado volver a conectarse\n ");
userpad.userList.removeAll();
en
putpad.userChoice.removeAll();
inputWords.setText("");
controlpad.connectButton.setEnabled(true); >
}
else
{
prueba
{
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(""); (verdadero );
}
}
}
}
clave vacía pública Typed(KeyEvent e)
{
}
clave vacía públicaReleased(KeyEvent e)
{
}
public static void main(String args[])
{
chessClient chessClient=new chessClient()
}
/****************************************** ** **********************************************
Lo siguiente es: chessInteface.java
********************************* ***** ********************************************** ****** ********/
importar java.awt.*;
importar java.awt.event.*; p>importar java.io .*;
importar java.net.*;
clase userPad extiende el Panel
{
Lista userList=nueva Lista(10);
userPad()
{
setLayout(nuevo BorderLayout()); int i=0;i <50;i++)
{
userList.add(i+"."+"Sin usuario"); /p>
add(userList,BorderLayout.CENTER);
}
}
extensión de chatPad de clase;
ds Panel
{
TextArea chatLineArea=new TextArea("",18,30,TextArea.SCROLLBARS_VERTICAL_ONLY
chatPad()
<); p>{setLayout(new 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=new Button("Crear juego");
Botón joinGameButton=new Button("Unirse al juego");
Botón cancelGameButton=new Button("Abandonar juego");
Botón exitGameButton=new Button; ( "Cerrar el programa");
controlPad()
{
setLayout(new FlowLayout(FlowLayout.LEFT)
);setBackground (Color.pink);
add(IPlabel);
add(inputIP);
add(connectButton);
añadir (creatGameButton);
añadir(unirseGameButton);
añadir(cancelarGameButton);
añadir(salirGameButton); >}
p>
}
clase inputPad extiende el Panel
{
TextField inputWords=new TextField("", 40);
Elección userChoice=new Choice();
inputPad()
{
setLayout(new FlowLayout(FlowLayout. IZQUIERDA));
for(int i=0;i<50;i++)
{
userChoice.addItem(i+"."+"No usuario");
}
userChoice.setSize(60,24);
add(userChoice);
add(inputWords
}
}
/************************ ************ **************************************** ************ ***********
Lo siguiente es: chessPad.java
***** *********
************************************************** * ****************************/
importar java.awt.*
importar java.awt.event.*;
importar java.io.*;
importar java.net.*
importar java.util . *;
clase chessThread extiende Thread
{
tablero de ajedrez chessPad
chessThread(tablero de ajedrez chessPad)
{
this.chesspad=chesspad;
}
public void sendMessage(String sndMessage)
{
prueba
{
chesspad.outData.writeUTF(sndMessage
}
catch(Exception ea)
;{
System.out.println("chessThread.sendMessage:"+ea
}
}
); public void AcceptMessage(String recMessage)
{
if(recMessage.startsWith("/chess "))
{
StringTokenizer userToken=new StringTokenizer(recMessage," ");
String chessToken
String[] chessOpt={"-1","-1","0"}; /p>
int chessOptNum=0;
while(userToken.hasMoreTokens())
{
chessToken=(String)userToken.nextToken ( " ");
if(chessOptNum>=1 && chessOptNum<=3)
{
ajedrezOpt[chessOptNum-1]=chessToken; > p>
}
chessOptNum++;
}
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 y vuelva a unirse");
}
else
{
/ /System .out.println(recMessage
}
}
public void run()
{
Mensaje de cadena="";
intenta
{
mientras(verdadero)
{
mensaje =chesspad.inData.readUTF();
acceptMessage(mensaje);
}
}
catch(IOException es). )
{
}
}
}
la clase chessPad extiende el Panel implementa MouseListener,ActionListener
{
int chessPoint_x=-1,chessPoint_y=-1,chessColor=1;
int chessBlack_x[]=new int[200];
int chessBlack_y[]=nuevo int[200];
int chessWhite_x[]=nuevo int[200]
int chessWhite_y[]=nuevo int[200];
p>
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;
DataOutputStream outData
Cadena chessSelfName=null;
Cadena chessPeerName=null
Cadena host=null;
int port=4331;
ChessThread chessthread=new chessThread(este);
chessPad()
{
setSize. (440,440);
setLayout(null);
setBackground(Color.pink);
addMouseListener(this); (statusText);
statusText.setBounds(40,5,360,24);
statusText.setEditable(false); >connectServer público booleano(String ServerIP,int ServerPort) arroja una excepción
{
p>
pruebe
{
chessSocket=new Socket(ServerIP,ServerPort)
inData=new DataInputStream(chessSocket.getInputStream());
outData=new DataOutputStream(chessSocket.getOutputStream());
chessthread.start()
devuelve verdadero;
catch(IOException ex)
{
statusText.setText("chessPad:connectServer:No se puede conectar\n"); > }
devuelve falso
}
ajedrez vacío públicoVictoria(int chessColorWin)
{
esto removeAll();
for(int i=0;i<=chessBlackCount;i++)
{
chessBlack_x[i]=0; p >
ajedrezNegro_y[i]=0;
}
for(int i=0;i<=chessWhiteCount;i++)
{ < / p>
ajedrezBlanco_x[i]=0
ajedrezBlanco_y[i]=0;
}
ajedrezNegroCount=0;
chessWhiteCount=0;
add(statusText);
statusText.setBounds(40,5,360,24
if(chessColorWin==1); )
{ chessBlackWin++;
statusText.setText("Las negras ganan, las negras y las blancas son "+chessBlackWin+":"+chessWhiteWin+", reinicia el juego, espera a que las blancas hagan una mover... ");
}
else if(chessColorWin==-1)
{
chessWhiteWin++;
statusText.setText("Las blancas ganan, las negras: las blancas son "+chessBlackWin+":"+chessWhiteWin+", reinicia el juego, espera a que las negras hagan un movimiento..."); >}
}
public void getLocation(int a,int b,int color)
{
if(color== 1)
{
ajedrezBlack_x[chessBlackCount]=a*20
ajedrezBlack_y[chessBlackCount]=b*20
ajedrezBlackCount++; ;
}
else if(color==-1)
{
chessWhite_x[chessWhiteCount]=a*20; /p>
ajedrezBlanco_y [ajedrezBlancoCount]=b*20
chessWhiteCount++;
}
}
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;paso<=4;paso++)
{
for(chessCompare=0;chessCompare<=chessBlackCount;chessCompare++ )
{
if(((a+paso)*20==chessBlack_x[chessCompare]) && ((b*20)==chessBlack_y[chessCompare]))
{
ajedrezEnlace=ajedrezEnlace+1
if(ajedrezEnlace==5)
{
return( verdadero
}
}
}
if(chessLink==(chessLinkTest+1))
chessLinkTest++;
else
romper;
}
for(paso=1;paso<=4;paso++)
{
for(chessCompare=0;chessCompare<=chessBlackCount;chessCompare++)
{
if(((un paso) *20==chessBlack_x[chessCompare]) && (b*20==chessBlack_y[chessCompare]))
{
chessLink++
if(chessLink= =5)
{
return(verdadero
}
}
}
if(chessLink==(chessLinkTest+1))
chessLinkTest++;
else
romper
}
ajedrezEnlace=1;
ajedrezEnlacePrueba=1
for(paso=1;paso<=4;paso++)
{
for(chessCompare=0;chessCompare<=chessBlackCount;chessCompare++)
{
if((a*20==chessBlack_x[chessCompare]) && (( b+paso)*20==chessBlack_y[chessCompare]))
{
chessLink++
if(chessLink==5)
{
return(verdadero
}
}
}
i;
f(chessLink==(chessLinkTest+1))
chessLinkTest++;
else
romper
}
for(paso=1;paso<=4;paso++)
{
for(chessCompare=0;chessCompare<=chessBlackCount;chessCompare++)
{
if((a*20==chessBlack_x[chessCompare]) && ((b-step)*20==chessBlack_y[chessCompare]))
{
ajedrezEnlace++;
if(ajedrezEnlace==5)
{
return(verdadero
}
}
}
if(chessLink==(chessLinkTest+1))
chessLinkTest++
else
; p>
else
p>
romper;
}
chessLink=1
chessLinkTest=1;
for(paso=1; paso<=4;paso++)
{
for(chessCompare=0;chessCompare<=chessBlackCount;chessCompare++)
{
if(((a-step)*20==chessBlack_x[chessCompare]) && ((b+step)*20==chessBlack_y[chessCompare]))
{
ajedrezEnlace++
if(ajedrezEnlace==5)
{
retorno(verdadero); p>
}
}
}
if(chessLink==(chessLinkTest+1))
chessLinkTest++; /p>
else
romper;
}
for(paso=1;paso<=4;paso++)
{
for(chessCompare= 0;chessCompare<=chessBlackCount;chessCompare++)
{
if(((un+paso)*20==chessBlack_x [chessCompare]) && ((b-step)*20 ==chessBlack_y[chessCompare]))
{
chessLink++
if(chessLink== 5)
{
retorno(verdadero
}
}
}
;if(chessLink==(chessLinkTest+1) )
chessLinkTest++;
else
romper
}
p>ajedrezEnlace=1;
ajedrezEnlaceT;
est=1;
for(paso=1;paso<=4;paso++)
{
for(chessCompare=0;chessCompare<=chessBlackCount; chessCompare++)
{
if(((a+paso)*20==chessBlack_x[chessCompare]) && ((b+paso)*20==chessBlack_y[chessCompare]) )
{
ajedrezEnlace++;
if(ajedrezEnlace==5)
{
return(verdadero).
}
}
}
if(chessLink==(chessLinkTest+1))
chessLinkTest++;
else
romper;
}
for(paso=1;paso<=4;paso++) p>
{
for(chessCompare=0;chessCompare<=chessBlackCount;chessCompare++)
{
if(((un paso )* 20==chessBlack_x[chessCompare]) && ((b-step)*20==chessBlack_y[chessCompare]))
{
chessLink++; >if (chessLink==5)
{
return(true
}
}
;