Código fuente java del pequeño foro
importar java.awt.*;
importar java.io.*;
importar java.net.*;
La clase pública TicTacToeclient extiende Applet para implementar Runnable
{//class1
Id. de campo de texto;
Panel boardpanel, panel2
Tablero cuadrado[][], cuadrado actual
Conexión de enchufe;
Entrada DataInputStream;
Salida DataOutputStream;
Rosca Hilo de salida;
char mymark
Visualización del área de texto;
Public void init()
{
establecer diseño(nuevo BorderLayout());
display=new TextArea(4, 30);
display.set editable(false);
Agregar( " Sur", pantalla);
Panel del tablero = nuevo Panel();
panel del tablero . establecer diseño(new GridLayout(3, 3, 0, 0));
Tablero = nuevo cuadrado [3][3]; lt longitud del tablero; fila++)
for(int col = 0; col & lt tablero[fila].
longitud; col++)
{
tablero[fila][col]=nuevo cuadrado();
repintar();
panel del tablero . add(board[row][col]);
}
id = new TextField();
id establecido (falso) ;
Agregar("Norte", id);
Panel 2 = nuevo Panel();
panel 2. agregar(panel del tablero);
p>
add("centro", panel 2);
}
///////////Fin
Public void start()
{
Pruebe {
conexión = new Socket(inet dirección . getlocalhost(), 5000
entrada = nuevo flujo de entrada de datos (conexión . getinputstream());
salida = nuevo flujo de salida de datos (conexión . obtener flujo de salida());
}
catch(IOException e){
//e . printstacktrace();
}
outputThread = nuevo hilo (este);
hilo de salida .start();
}
///////////End
Booleano público mouseUP(evento e, int x, int y)
{
for(int fila = 0; fila & lt longitud del tablero; fila++)
{
for(int col = 0; col & lt tabla[fila].
longitud; col++)
prueba {
if (por ejemplo, objetivo == tablero[fila][columna])
{
actual cuadrado = tablero[fila][col];
salida escribe int(fila * 3+col);
}
}
<. p>catch(IOException es decir){//es decir, printstacktrace();
}
}
Devuelve verdadero
p>}
///////////Fin
Ejecución de vacío público()
{
Pruebe {
mi marca = input . read char();
Id.setText("Bienvenido a jugar\ " "+mimarca+" \ ");
}
catch(IOException e){
e . printstacktrace();
}
mientras (verdadero)<. /p>
{
Prueba {
string s = input utf();
processMessage
}<. /p>
catch(IOException e){
//e . printstacktrace();
}
}
. }
///////////Fin
Proceso de anulación públicaMensaje(cadena s)
{
si (s es igual a ("movimiento válido"))
{
display.appendText("movimiento válido, espere\n ");
cuadrado actual. set mark(mi marca);
cuadrado actual . repaint();
}
else if(s.equals("Mover no válido, repintar Intentar " ))
{
display . appendtext(s+" \ n ");
}
else if(s. es igual a( "movimientos del oponente"))
{
Pruebe {
int loc = input ;
Completar:
for(int fila = 0; fila & lt longitud del tablero; fila++)
for(int col = 0; col & lt tablero[fila]. longitud; col++)
if(fila*3+col==loc)
{
Tablero [fila][columna]. setMark(mymark=='x '?o ':' x ');
Tablero [fila][columna]. repaint();
Descanso completado;
}
display.appendText("El oponente se movió.
Es tu turno\n ");
}
catch(IOException e){
e . printstacktrace();
}
}
Otro
{
display .appendtext(s+" \ n ");
}
}//class1.end
////////////////////// //////////////////
Lienzo extendido cuadrado de clase
{//class2
Etiqueta de carácter;
Plaza pública()
{
Redimensionar(30,30);
}
// /////////Fin
Marca de configuración vacía pública (char c)
{
mark = c;
}
///////////Fin
Pintura pública en blanco (gráfico g)
{
g.drawRect(0, 0, 29, 29);
g . cordón (cadena . valor de (marca),
}
<); p>}//class2.end//& lt; código del subprograma = " tictactoeclient . class " ancho = 275 alto = 300 > Lado del servidor:
Importar Java.awt.*;
Importar Java.net.*;
Importar Java.io.*;
Marco de extensión TicTacToeServer de clase pública
{//class1
ByteBoard privado[];
XMove booleano privado
salida TextArea privada ;
jugadores privados[];
servidor de socket privado
número de jugadores int privado
jugador actual int privado
TicTacToeServer público()
{
Super("Servidor de ajedrez Three Sons");
tablero = nuevo byte[ 9];
xMove = true
Jugador = nuevo jugador[2];
jugador actual = 0;
Prueba {
servidor=new ServerSocket(5000, 2);
}
catch(IOException e){
//e .
sistema . salida(1);
}
salida = new TextArea();
salida establecida (color . amarillo);
add("centrado", salida);
Ajustar tamaño (300, 300);
show();
kit de herramientas TP = kit de herramientas . getdefaulttoolkit();
logotipo de imagen = TP . getimage(" 1 . gif "); falso);
<p>}
///////////Fin
ejecutar public void()
{
para (int I = 0; i & lt jugadores.length; i++)
{
prueba{
jugadores[I] = nuevos jugadores(server.accept (), este, yo);
Jugador [I]. start();
++ número de jugadores;
}
catch(IOException e){
//e . ();
sistema . salida(1);
}
}
}
// /////////End
public int getNumberOfplayers()
{
Devolver número de jugadores
}
///////////Fin
Visualización pública vacía (cadena s)
{
salida appendtext( s+. " \ n ");
}
//////////Fin
Movimiento válido booleano público (int loc, int player)
{
movimiento booleanoDone = false
mientras (¡jugador! = jugador actual)
{
Prueba {
wait();
}
catch(excepción interrumpida e){//not
}
}
if (producto igual (loc))
{
tablero[loc]=(byte)(reproductor actual == 0?x ': ' o ');
jugador actual = ++ jugador actual % 2;
Jugador [jugador actual]. otro jugador se movió(loc);
notificar();
Devolver verdadero
}
Otro
Devuelve falso
}
///////////End
Producto igual booleano público (int loc)
{
if(board[loc]= = ' x ' | | board[loc]= = ' o ')
Devuelve verdadero
Otros
Devuelve falso
}
///////////Fin
Evento booleano público (evento de evento)
{
if(event.id==Event.Window_destroy)
{
ocultar();
dispose();
for(int I = 0; i<player.length;i++)
jugador[i].
stop();
sistema . exit(0);
}
Devuelve super.handleEvent(evento);
}
///////////Fin
Juego booleano públicoOver()
{
Devuelve falso
}
///////////Fin
Public static void main(String args[])
{
Juego TicTacToeServer = nuevo TicTacToeServer();
juego ejecutar();
}
}//class1.end
////////////////////////////////////////////// /// /////Siguiente lección
Hilo de extensión del reproductor de clase
{//class2
Conexión de socket;
DataInputStream Entrada;
Salida de DataOutputStream;
Control TicTacToeServer;
Número int
Marca de carácter; jugador(socket s, TicTacToeServer t, int num)
{
mark=(num==0?x ':' o ');
conexión = s;
Prueba {
entrada = nuevo flujo de entrada de datos (conexión . getinputstream());
salida = nuevo flujo de salida de datos (conexión . obtener salida stream());
}
catch(IOException e){
//e . printstacktrale();
sistema. salida(1);
}
control = t;
número = num
}
/ //////////Fin
public void otro jugador se movió(int loc)
{
Intentar{
salida .escribir utf(" Opponet se movió ");
salida escribir int(loc);
catch(IOException e) {// no
}
}
///////////Fin
Vacío público en ejecución ( )
{
Booleano hecho = false
Pruebe {
control display(" player "+(número == 0? X': 'o')+"¡Iniciar sesión!");
salida escribe char(marca);
salida escribe utf(" jugador "+(número = =. 0 ?" {
Output.writeUTF("¡Espere a que otro jugador inicie sesión!");
while(control . g
etnumberofplayers()<2);
Output.writeUTF("¡Otro jugador ha iniciado sesión! ¡Ahora puedes jugar al ajedrez!");
}
Y (! hecho)
{
int ubicación = input . readint();
if(control.validMove(ubicación, número))
{
control . display(" loc "+ubicación);
output.writeUTF("Movimiento válido.");
}
Otros
output.writeUTF("Movimiento no válido, inténtalo de nuevo");
if(control.gameOver())
{
hecho = verdadero
}
conexión .close();
}
}
catch(IOException e){
e . printstacktrace();
salir(1); p>}
}//clase.end