¿Cuál es el código fuente de autorización del Mini Program Mall?
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];
for(int fila = 0; fila lt; tabla larga; fila)
for(int col = 0; col lt tabla[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(event e, int x, int y)
{
for(int fila = 0; fila lt longitud del tablero; fila)
{
for(int col = 0; col lt tablero[fila].
longitud; col )
pruebe {
if (por ejemplo, target==board[row][col])
{
cuadrado actual = tablero[fila][col];
salida escribir int(fila * 3 col);
}
}
.catch(IOException es decir){
//es decir, printstacktrace();
}
}
Devuelve verdadero< / p>
}
///////////Fin
Ejecución de vacío público()
{
Prueba {
my mark = input . read char();
Id.setText("Bienvenido a jugar \ " " mymark " \ ");
}
catch(IOException e){
e . printstacktrace();
}
mientras (verdadero)<. /p >
{
Prueba {
string s = input utf();
processMessage
}<. /p >
catch(IOException e){
//e . }
///////////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("Movimiento no válido, inténtalo de nuevo" ))
{
display . appendtext(s " \ n ");
}
else if(s.equals(); "El oponente se mueve"))
{
Prueba {
int loc = input ;
Completar:
p>
for(int fila = 0; fila lt longitud del tablero; fila)
for(int col = 0; col lt longitud del tablero [fila]. longitud; col )
if(fila*3 col==loc)
{
Tablero [fila][columna]. setMark(mymark=='x '?o ':' x ');
Tablero [fila][columna]. repaint();
El resto está completo;
}
display.appendText("El oponente se ha movido.
Es tu turno\n ");
}
catch(IOException e){
e . printstacktrace();
}
}
Otro
{
pantalla 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 gt;
Importar Java.awt.*;
Importar Java.net.*;
Importar Java.io.*;
Público Marco de extensión de clase TicTacToeServer
{//class1
ByteBoard privado[];
XMove booleano privado
Salida de TextArea privada
Jugadores privados[];
Servidor de socket privado
número de jugadores int privado
jugador actual int privado
Public TicTacToeServer()
{
Super("Three Sons Chess Server");
tablero = nuevo byte[9];
xMove = true
Player=new player[2];
jugador actual = 0;
Prueba {
server=new ServerSocket(5000, 2);
}
catch(IOException e){
//e . p>
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();
ima.
ge logotipo = TP . getimage(" 1 . gif ");
imagen de seticon(logotipo);
setResizable(false); >
///////////Fin
ejecutar public void()
{
for(int I = 0; i lt jugadores. longitud; i )
{
prueba {
jugadores[I] = nuevos jugadores(server.accept(), esto, I) ;
Jugador [yo]. 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 ");
}
///////////end
Movimiento válido booleano público (int loc, int player)
{
movimiento booleanoDone = false
mientras (¡jugador! = jugador actual)
{
intentar{
wait();
}
catch(excepción interrumpida e){//not
}
}
if (producto igual (loc))
{
tablero[loc]=(byte)(jugador 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 lt player.length; i)
player[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. escribir char(marca);
salida escribir utf(" jugador " (número == 0? " ¡X aterrizó! \n": "oPara iniciar sesión, ¡espera! \n "));
if(control
. getnumberofplayers() lt; 2)
{
Output.writeUTF("¡Espere a que otro jugador inicie sesión!"); . getnumberofplayers () lt; 2);
Output.writeUTF("¡Otro jugador ha iniciado sesión! ¡Ahora puedes jugar al ajedrez!"); > while (! hecho)
{
int ubicación = entrada . readint();
if(control.validMove(ubicación, número))
{
control . display(ubicación" loc ");
output.writeUTF("Movimiento válido."); / p>
Otro
output.writeUTF("Movimiento no válido, inténtalo de nuevo");
if(control.gameOver())
{
hecho = verdadero
}
conexión .
}
}
catch(IOException e){
e . printstacktrace();
salir(1); p >}
}//clase.end