You are on page 1of 19

1

VRML 2.0 con Java CAPÍTULO 22

Una Interfaz de Ajedrez

Contenido CAPÍTULO 22

• ¿Cómo la solicitud de trabajo


2

VRML 2.0 con Java CAPÍTULO 22

• Creación de la Junta y Piezas de ajedrez


• La Aplicación
• Todo en conjunto
• Orientación futura

En este capítulo vamos a estudiar la manera de USO VRML y Java para crear un
gráfico tridimensional delantera para jugar ajedrez. Aunque la aplicación de un
3

VRML 2.0 con Java CAPÍTULO 22

completo programa de ajedrez más allá del alcance de este libro, el código de
este capítulo se puede utilizar fácilmente para proporcionar la interfaz de
usuario para aplicaciones de ajedrez entre los usuarios o entre un usuario y el
ordenador.

Nuestro diseño debe tener dos objetivos básicos: mínimo tamaño de archivo a
fin de garantizar la rápida descarga, y la flexibilidad a fin de que el código
adaptables a auténtico ajedrez aplicaciones. En el curso de la ejecución de este
proyecto, vamos a aprender más acerca de algunas características importantes
de VRML, como instancia, prototipos, el nodo de extrusión, PlaneSensors,
PixelTextures, y el uso de la interfaz externa Autor (EAI).

La forma en que la aplicación funcione

La solicitud constará de dos partes: una que describe el archivo VRML tablero y
piezas, y un applet de Java para manejar la interacción. Usaremos la
PlaneSensor nodo de VRML para que el jugador agarre de piezas y arrastre en
torno a la placa. Estos movimientos serán procesados por un applet que se
ejecuta en la misma página HTML y se comunica con el mundo VRML a través
del navegador de la Autoría de la interfaz externa.

NOTA: Recuerde que la EAI no es una parte obligatoria de la especificación


de VRML, por lo que no puede ser aplicado en todos los navegadores. El código
de este capítulo fue probada con Cosmo Player.

Creación de la Junta y Piezas de ajedrez

Nuestro primer paso será crear el VRML de datos de ajedrez para nuestra
aplicación. Se compone de dos partes: la junta directiva y las piezas.
La Junta

Dado que uno de nuestros objetivos es mantener el tamaño de nuestro archivo,


vamos a utilizar un solo de cuatro puntos IndexedFaceSet de la placa. El patrón
de tablero de ajedrez será generado con PixelTexture un nodo, a fin de evitar
tener que descargar una imagen GIF o JPEG. Gran parte del tiempo que se
tarda en descargar una gran textura VRML mundo se gasta en el
establecimiento de las necesarias conexiones HTTP, evitando así el uso de un
mapa de textura reduce drásticamente el tiempo de descarga.

El consejo es muy simple. El aspecto que presenta es:

Forma (
apariencia apariencia (
4

VRML 2.0 con Java CAPÍTULO 22

textura PixelTexture (
imagen 2 2 1 0xFF 0x00 0x00 0xFF
)
)
geometría IndexedFaceSet (
coord Coordinar (
punto [
-0,48 0 -0,48,
-0,48 0 0,48,
0,48 0 0,48,
0,49 0,48 0 -0,48
]
)
texCoord TextureCoordinate (
punto [0 0, 0 4 4 4 4 0]
)
coordIndex [0 1 2 3 -1]
)
)

El PixelTexture nodo contiene un 2-por-2 imagen, 1 byte de profundidad. El


0xFF 0x00 0x00 0xFF bytes son la texels (píxeles de la textura), lo que forma
un patrón de tablero de ajedrez como se muestra en la Figura 22.1.

Figura 22-1 Cómo los 4 octetos definir el patrón de tablero de ajedrez

La junta está diseñada con el origen en el centro, de manera que rota en torno
a examinar el modo en que permite al usuario ver el bordo desde diversos
ángulos. Las coordenadas de las cuatro esquinas de la junta son elegidos para
ser múltiplos de 8, a fin de que el posicionamiento de las piezas más fácil.

Anuncio en el código anterior que las coordenadas de textura rango de 0 a 4 en


lugar de 0 a 1. Esto se traduce en la textura se repite cuatro veces en cada
dirección, que es como un 2-por-2 textura se convirtió en un 8-en-8 patrón de
tablero de ajedrez.

La junta se define por los cuatro vértices. Observe que dejamos el pabellón
5

VRML 2.0 con Java CAPÍTULO 22

conjunto sólido de su valor por defecto de TRUE. Esto mejora el rendimiento un


poco, pero significa que la junta sólo está visible desde arriba. Por supuesto, si
el usuario está por debajo de la placa, entonces probablemente la mitad está
dormido y no se debe jugar el ajedrez de todos modos.

La junta terminada se muestra en la Figura 22.2. Con nuestro completo bordo,


es el momento de pasar a las piezas.

Figura 22.2 El tablero de ajedrez


El Piezas

A medida que el diseño de las piezas de nuestra junta, tenemos que mantener
nuestros objetivos de diseño claramente en mente. En particular, queremos
mantener el archivo pequeño.

Almacenamiento de 32 piezas separadas jugando como haría IndexedFaceSets


el archivo enorme. ¿Hay alguna manera de reducir la cantidad de datos que se
requiere para representar a cada pieza?

La respuesta, por supuesto, es sí. Todos los sistemas de compresión se basan


en la existencia de algo de redundancia en los datos comprimidos, y hay una
gran cantidad de redundancia en las 32 piezas de ajedrez. Los ocho peones del
negro son idénticos entre sí, y los peones blancos son los mismos pero con un
color diferente. Hay cuatro casos de la torre (dos negro, dos blancos), cuatro
casos de caballero, cuatro casos del obispo, y dos casos de cada uno de los
monarcas.

Además, habrá varias características que todas las piezas de ajedrez compartir.
Por ejemplo, ellos necesitan un nodo de transformación para pasar a su lugar
en la placa, y todos ellos necesitan tener un PlaneSensor que se les otorga
para que el usuario pueda moverse alrededor de ellos, y así sucesivamente.
Usando PROTO

Una técnica que no sólo reduce el tamaño del archivo, sino también hace más
fácil para crear las piezas es utilizar prototipos. Vamos a crear un prototipo de
una pieza de ajedrez genéricos y la creación de instancias de PROTO que para
cada pieza. El PROTO tendrá la pieza de la forma, color y ubicación inicial en el
tablero como parámetros.
6

VRML 2.0 con Java CAPÍTULO 22

El PROTO tendrá este aspecto:

PROTO pieza [
campo SFNode apariencia NULL
campo SFNode geometría NULL
exposedField SFVec3f initialLocation 0 0 0
eventIn SFVec3f set_location
eventOut SFVec3f location_changed
eventOut SFBool isActive
]
(
Transformar (
rotación 1 0 0 1,5708
traducción es initialLocation
los niños [
DEF transformación (T
Escala 0,03 0,10 0,03
rotación 1 0 0 -1,5708
set_translation ES set_location
translation_changed ES location_changed
Forma niños (
apariencia es la apariencia
geometría es la geometría
)
)
DEF PS isActive PlaneSensor (ES) isActive
]
)
VÍA PS.translation_changed A T.set_translation
)

Hay varias cosas a la nota acerca de este fragmento de código VRML. La


primera es que la apariencia y la geometría como se especifican los campos,
en lugar de exposedFields. Esto es debido a que se establecerá una sola vez,
cuando la obra es creada, y no cambiará nunca.

La segunda cosa a tener en cuenta es que el initialLocation de la pieza es un


exposedField. Este valor se fijará cuando la pieza se inicializa, pero vamos a
querer leer más adelante, cuando la aplicación de nuestro applet de Java.
Podríamos utilizar un campo y un eventOut, pero en este caso es igual de fácil
para que sea un exposedField.

El location_changed eventOut se requiere para que el applet para poder leer la


7

VRML 2.0 con Java CAPÍTULO 22

ubicación de la pieza.

El isActive eventOut es TRUE cuando el usuario está moviendo una pieza, y va


FALSE cuando la liberación de la pieza. Nuestro applet reconocerá esta
transición y lo utilizan para determinar cuando una pieza se ha movido. Así
como en el ajedrez, el movimiento se considera completa cuando el usuario
suelta la pieza.
Usando PlaneSensor

Usted puede preguntarse por qué tenemos dos nodos anidados Transformar a
la posición de la pieza. Sin duda, una es suficiente para colocar la pieza en el
tablero. ¿Y cuáles son las rotaciones para?

Las respuestas a estas preguntas se encuentran en la forma en que el nodo se


define PlaneSensor. El PlaneSensor permite que el usuario haga clic en una
forma y arrástrelo alrededor. El PlaneSensor se activa cuando alguno de sus
hermanos (o sus descendientes) se hace clic en, lo que significa que queremos
que la forma de nodo de una pieza a ser un hermano o descendiente de un
hermano de la PlaneSensor.

Queremos que el arrastre de la PlaneSensor para afectar a la posición de la


forma que corresponde a la pieza, por lo que debe envolver de forma que
dentro de una transformación. El PlaneSensor del translation_changed
eventOut que se dirige a la transformación set_translation eventIn. Desde la
PlaneSensor y que afecta a la transformación debe ser hermanos, tenemos que
envolver a los dos dentro de un nodo de agrupación, en este caso, es otro de
transformación.

Esto explica por qué tenemos dos anidados transforma, pero ¿qué hay de las
dos vueltas? Una vez más, la respuesta reside en la forma en que las obras
PlaneSensor.

La acción de arrastrar el PlaneSensor siempre ocurre en el plano xy del sistema


de coordenadas en el que el sensor existe. Desde nuestro tablero de ajedrez se
encuentra en el plano yz, debemos girar la PlaneSensor (y, por tanto, sus
hermanos), a través de 90 grados alrededor del eje x (1 0 0 1,5708) en la
transformación que les encierra. Sin embargo, esto convierte a la pieza de
lado, que no es lo que queremos; resolvemos esto estableciendo una rotación
de -90 grados alrededor del eje x (1 0 0 -1,5708) en el interior de
transformación que incluye la pieza Forma. En otras palabras, utilizamos el
centro de transformación para rotar la pieza de modo que es tumbado sobre un
lado, traducir en el plano xy mediante el PlaneSensor, a continuación, gírelo de
nuevo en el plano xz de transformación mediante el exterior. Vamos a utilizar
también que Transforma exterior para fijar el initialLocation de la pieza.
8

VRML 2.0 con Java CAPÍTULO 22

El PlaneSensor del isActive eventOut es una práctica forma de saber cuando el


usuario ha dejado de ir de la pieza, y es expuesto utilizando SE.
Uso de la extrusión del Nodo

El mayor elemento de un típico archivo VRML (sin contar los mapas de texturas
y muestras de sonido, que se almacenan externamente) es la geometría que
está almacenado en un IndexedFaceSet. La próxima formato binario para VRML
abordará este problema mediante el uso de técnicas de compresión
geométrica, pero todavía tiene sentido para reducir nuestra geometría tanto
como sea posible.

Haremos que al evitar el uso de voluminosos IndexedFaceSets completo. En


lugar de ello, usaremos una de las más poderosas técnicas para crear la
geometría en VRML: el nodo de extrusión.

A fin de ilustrar cómo funciona esto, veamos el Obispo Blanco. Empezamos por
la definición de una sección circular, compuesto de 16 puntos que yacen en el
plano xz, como se muestra en la Figura 22.3.

Figura 22.3 Los 16 vértices de la sección transversal

A continuación, definimos una columna que a lo largo de esta sección se


extruido. Para todas nuestras formas excepto los caballeros, esta columna será
una simple línea vertical (la creación de una pieza circular); sin embargo, será
dividido en una serie de segmentos que serán en diferentes alturas de cada
pieza. La ampliación de la forma también varían de una pieza a otra.

Por ejemplo, aquí está la forma en que el obispo de color blanco se crea usando
un nodo de extrusión:

Extrusión (
crossSection [
1 0, 0,92388 -0,382683, 0,707107 -0,70107,
0,38283 -0,92388, 0 -1,
-0,38283 -0,92388, -0,707107 -0,70107,
-0,92388 -0,382683, -1 0,
-0,92388 0,382683, -0,707107 0,70107,
-0,38283 0,92388, 0 1,
0,38283 0,92388, 0,707107 0,70107,
0,92388 0,382683, 1 0
]
columna [
9

VRML 2.0 con Java CAPÍTULO 22

0 0 0, 0 0,10 0, 0 0,10 0, 0 0,75 0,


0 0,95 0, 0 1,05 0, 0 1,25 0, 0 1,5 0
]
escala [
1 1 1, 1, 0,85 0,85, 0,2 0,2,
0,50 0,50 0,90 0,90 0,5 0,5 0,1 0,1
]
)

El crossSection campo contiene los 16 vértices que hemos definido antes. La


columna vertebral campo especifica una ruta de ocho segmentos que la
sección transversal será de extrusión a lo largo, y la escala sobre el terreno da
la cantidad en que la sección transversal debe ampliarse en cada uno de los
ocho puntos. La pieza resultante se muestra en la Figura 22.4.

Figura 22.4 El obispo blanco

Las otras piezas de ajedrez son muy similares a este, a excepción de los
caballeros. Su columna vertebral no es una línea recta, sino que alrededor de
las curvas en una especie de cuestión, que forma.

NOTA: Usted encontrará el código de todas las piezas en el CD-ROM que


acompaña a este libro.

El código para el caballero se muestra a continuación. Este código también


muestra la forma en que el nodo de extrusión se usa en el campo de la
geometría de nuestro PROTO pieza y cómo el color de la pieza se especifica
mediante un nodo Apariencia.

DEF WhiteKnight1 Pieza (


DEF apariencia Blanco Aspecto (
material Material (diffuseColor 1 1 1)
)
DEF KnightShape geometría
Extrusión (
crossSection [
1 0, 0,92388 -0,382683, 0,707107 -0,70107,
10

VRML 2.0 con Java CAPÍTULO 22

0,38283 -0,92388, 0 -1,


-0,38283 -0,92388, -0,707107 -0,70107,
-0,92388 -0,382683, -1 0,
-0,92388 0,382683, -0,707107 0,70107,
-0,38283 0,92388, 0 1,
0,38283 0,92388, 0,707107 0,70107,
0,92388 0,382683, 1 0
]
columna [
0 0 0,
0 0,2 0,
0 0,2 0,
0 0,5 0,
0 0,7 0,5,
0 0,8 1,
0 1,0 0,5,
0 1,1 0,
0 1,0 -0,5,
0 0,8 -1
]
escala [
1 1,
1 1,
0,85 0,85,
0,25 0,25,
0,25 0,25,
0,15 0,15,
0,25 0,25,
0,25 0,25,
0,25 0,25,
0,15 0,15
]
)
initialLocation -0,30 0 0,42
)

El consejo pasa de -0,48 a 0,48 en la X y Z direcciones. Esto significa que toda


la junta es 0,96 metros de ancho, que en realidad es bastante grande para un
tablero de ajedrez. Dado que hay ocho plazas en cada dirección, cada plaza
debe ser 0,12 metros en la dirección x y 0,12 metros en la dirección z. El
initialLocation de este caballero es de color blanco (-0,30 0 0,42), que lo coloca
en la ubicación correcta en el tablero de ajedrez.
Uso de DEF y USE
11

VRML 2.0 con Java CAPÍTULO 22

El mayor ahorro en el tamaño del archivo proviene de la utilización de la


instancia. Instancia consiste en nombrar a un nodo en particular mediante DEF,
y, posteriormente, mediante la reutilización de USO. Porque la mayoría de los
navegadores se mantendrá una única copia del nodo en la memoria y el uso de
indicadores se refieren a ella en los siguientes usos, esta técnica no sólo
reduce el tamaño del archivo y el tiempo de descarga, sino también los
requisitos de memoria para nuestro mundo.

En el ejemplo anterior, el nombre asignado a la Apariencia Blanco nodo que


define el material que va a utilizar para todas las piezas blancas en el tablero.
También asigna el nombre de Knight a la extrusión nodo que define la
geometría para el caballero. Estos DEFS nos permitirá ejemplo, la geometría y
material que necesita para su posterior piezas. Por ejemplo, haber definido la
primera peón blanco, esto es lo que el segundo peón blanco tiene el siguiente
aspecto:

DEF WhitePawn2 Pieza (


USO apariencia blanca
geometría USO PawnShape
initialLocation -0,30 0 0,30
)

Usted también notará que todas las piezas se les asignan nombres como
WhiteKnight1 y WhitePawn2. Estos nombres no tienen nada que ver con
instancias, sino que son utilizados para proporcionar una manera para que el
applet para identificar y tener acceso a las piezas. Esto se aclarará más
adelante en este capítulo cuando se inicie la aplicación de nuestro applet de
Java.
Diversos nodos

En nuestra junta y piezas en su lugar, el último paso consiste en proporcionar


algunos detalles para el usuario. Vamos a añadir tres puntos de vista (uno de
Blanco el punto de vista, uno de Negro el punto de vista, y uno de la anterior) y
configurar el modo de navegación para examinar:

NavigationInfo (type "EXAMINE")

# Los puntos de vista

Punto de vista (
posición 0 1 1
orientación 1 0 0 -0,7854
descripción "Blanco el punto de vista"
)
12

VRML 2.0 con Java CAPÍTULO 22

Punto de vista (
posición 0 1 -1
orientación 0 0,9238 0,3827 3,14159
descripción "Negro el punto de vista"
)

Punto de vista (
posición 0 1,5 0
orientación 1 0 0 -1,5708
descripción "vista aérea"
)

El acabado bordo, con todas las piezas en él, se muestra en la Figura 22.5.

Figura 22.5 El tablero de ajedrez terminado

Todo el tablero y las 32 piezas son algo más de 10K sin comprimir. Con la
compresión, el tamaño del archivo podría bajar a apenas 3K, que se descarga
en poco más de 1 segundo sobre un simple módem de 28.8 kbps-.
El Applet

Ahora que nuestro mundo está construido, es el momento de crear el applet


que responda a los movimientos de las piezas.

El applet se inicia el camino la mayoría de los applets de hacer, con una serie
de declaraciones de importación. Entre ellos se encuentran
vrml.external.Browser, vrml.external.Node, vrml.external.field .*, y
vrml.external.exception .*. Estas declaraciones proporcionan acceso a las
clases de la interfaz externa de autoría. Ellos son generalmente instaladas en
java / clases cuando un navegador que soporte el EAI (como Cosmo Player o
Worldview) está instalado:

/ / La aplicación de Ajedrez

/ / Escrito por Bernie Roehl, marzo de 1997

importación java.applet .*;


importación java.util .*;
13

VRML 2.0 con Java CAPÍTULO 22

importación java.awt .*;


importación java.io. *;
netscape.javascript.JSObject de importación;
vrml.external.Browser de importación;
vrml.external.Node de importación;
importación vrml.external.field .*;
importación vrml.external.exception .*;

A continuación, se define la aplicación en sí. Es una clase que extiende la clase


base Applet. Dado que vamos a estar recibiendo llamadas desde el navegador
de VRML, que especificar que la clase implementa la interfaz
EventOutObserver:

público de clase de ajedrez


extiende Applet
implementa ejecutable, EventOutObserver (

MyThread hilo;
Navegador navegador / / el navegador de VRML

getAppletInfo public String () (


retorno "de VRML Ajedrez interfaz" 0,1
", Escrito por Bernie Roehl";
)

El getAppletInfo () sea el método utilizado por el navegador para recuperar una


cadena que describe este applet. No es estrictamente necesario para facilitar
esta, pero es una buena idea.

Observe que también declarar una variable de instancia llamado navegador.


Esta variable es una referencia al propio navegador de VRML, que tendremos
que utilizar para acceder a los nodos del VRML mundo que hemos creado.

El Ajedrez Piezas en Java

A continuación crear una serie de piezas de ajedrez. La pieza de la clase será


examinado más adelante, por ahora, todo lo que necesitamos saber es que
estamos creando una serie de piezas de ajedrez, cada uno de los cuales se le
asigna un nombre específico que corresponde a la DEF nombres que fueron
asignados a las piezas de la VRML el archivo:

Pieza piezas [] = (
nueva pieza ( "BlackRook1"), las nuevas piezas ( "BlackKnight1"),
14

VRML 2.0 con Java CAPÍTULO 22

nueva pieza ( "BlackBishop1"),


nueva pieza ( "BlackKing"), las nuevas piezas ( "BlackQueen"),
nueva pieza ( "BlackBishop2"), las nuevas piezas ( "BlackKnight2"),
nueva pieza ( "BlackRook2"),
nueva pieza ( "BlackPawn1"), las nuevas piezas ( "BlackPawn2"),
nueva pieza ( "BlackPawn3"), las nuevas piezas ( "BlackPawn4"),
nueva pieza ( "BlackPawn5"), las nuevas piezas ( "BlackPawn6"),
nueva pieza ( "BlackPawn7"), las nuevas piezas ( "BlackPawn8"),
nueva pieza ( "WhiteRook1"), las nuevas piezas ( "WhiteKnight1"),
nueva pieza ( "WhiteBishop1"),
nueva pieza ( "WhiteKing"), las nuevas piezas ( "WhiteQueen"),
nueva pieza ( "WhiteBishop2"), las nuevas piezas ( "WhiteKnight2"),
nueva pieza ( "WhiteRook2"),
nueva pieza ( "WhitePawn1"), las nuevas piezas ( "WhitePawn2"),
nueva pieza ( "WhitePawn3"), las nuevas piezas ( "WhitePawn4"),
nueva pieza ( "WhitePawn5"), las nuevas piezas ( "WhitePawn6"),
nueva pieza ( "WhitePawn7"), las nuevas piezas ( "WhitePawn8")
);

Esta matriz se utiliza para realizar un seguimiento de las piezas propias, y se


usa sólo en el inicio () método:

public void start () (


= getBrowser navegador ();
for (int i = 0; i <pieces.length; + + i)
piezas [i]. reinicie (navegador, este);
if (myThread == null)
myThread = new Hilo (este);
myThread.start ();
)

Este método destaca una interesante y, a menudo pasado por alto los aspectos
de la autoría de interfaz externa, que ha sido una fuente de confusión para los
desarrolladores: El navegador manejar (que en este caso es devuelto por el
getBrowser () el método) no es necesariamente válida para toda la ejecución
del applet. Cuando se reinicia el applet, es necesario obtener una vez más una
referencia en el navegador.

Además, cualquier referencia a los datos en el navegador también puede estar


fuera de fecha. Esta es la razón por la que mantener nuestras piezas en un
conjunto; tenemos que correr a través de ellos cuando start () se llama, y llame
a cada uno de reiniciar () método.
Conexión a la del navegador
15

VRML 2.0 con Java CAPÍTULO 22

El getBrowser () método es similar al siguiente:

Navegador getBrowser privado () (


Navegador navegador Browser.getBrowser = ();
if (navegador == null) (
JSObject ganar = JSObject.getWindow (este);
if (ganar! = null) (
JSObject doc = (JSObject) win.getMember ( "documento");
JSObject incrusta = (JSObject) doc.getMember ( "incrusta");
for (int i = 0; i <10; i + +) (
= navegador (Browser) embeds.getSlot (0);
if (navegador! = null)
break;
try (Thread.sleep (500);)
de capturas (InterruptedException e) ()
)
)
)
retorno del navegador;
)

El getBrowser () método comienza llamando Browser.getBrowser (). Si por


alguna razón que los métodos no, nuestro getBrowser () cae de nuevo método
en la utilización de un objeto de JavaScript para acceder al documento actual y
el navegador de VRML incrustado en ese documento. Diez intentos se hacen,
con un retraso medio segundo después de cada intento, en caso de que el
navegador tiene un tiempo de carga.
Movimiento de la manipulación de piezas

El ajedrez define un objeto de devolución de llamada () método que responda a


los eventos isActive que se envían de las piezas siempre que sus PlaneSensor o
se toca sin tocar:

public void llamada (EventOut caso, el doble de tiempo, objeto UserData) (


EventOutSFBool activa = (EventOutSFBool) evento;
if (active.getValue ())
retorno;
Pieza pieza = (Pieza) UserData;
piece.updateLocation ();
flotado [] loc = piece.getLocation ();
int rango = 4 - (int) Math.floor (loc [1] / 0,12);
int file = 5 + (int) Math.floor (loc [0] / 0,12);
System.out.print (piece.getName () + "se trasladó a");
System.out.println ( "[" rango de + + "," + + "]"); archivo
16

VRML 2.0 con Java CAPÍTULO 22

La llamada ignora los hechos reales, ya que se preocupa sólo cuando el usuario
le permite ir de la pieza, cuando no cogerla. A continuación, examina el
UserData para esta llamada, que será una referencia a la pieza que está siendo
trasladado. Le dice a la obra para actualizar su propia idea de su ubicación
actual, y luego se recupera.

A continuación, la llamada tiene las coordenadas xey y convierte a las filas (es
decir, fila y columna) que la pieza está encendido. Esto se hace dividiendo por
la coordenadas X y Z por el tamaño de un cuadrado y añadiendo un offset.
Recuerde que el origen (0 0 0) se encuentra en el cruce de las cuatro plazas en
el centro del tablero.

Por último, la llamada imprime el ajedrez paso a la salida estándar para que el
usuario pueda ver. Ellos necesitan tener la consola de Java visibles para poder
ver esta información.

Tenga en cuenta que esto se hace sólo para la depuración. En la práctica, el


traslado sería convertir a un formato estándar y se envían a un juego de
ajedrez o programa a otro usuario humano.
La pieza de la clase

Como vimos anteriormente, las piezas están representadas por instancias de la


clase Pieza. Una pieza contiene el nombre de la pieza, que está especificado
como un parámetro para el constructor. Una pieza también tiene una referencia
al nodo de VRML para la pieza, tal como se define por el PROTO que hemos
examinado anteriormente. Objetos de la clase Pieza también almacenar la
ubicación actual y la ubicación inicial de la pieza en el tablero.

Pedazo de clase (
String name;
Nodo nodo;
flotado [] = new initialLocation flotar [3];
flotado [] = new currentLocation flotar [3];

Pieza público (String nam) (


name = nam;
)

Hay una getName () para permitir que el nombre de la pieza a ser recuperado,
y un getLocation () para devolver la ubicación de la pieza en el tablero.

Cadena getName () (return nombre;)


17

VRML 2.0 con Java CAPÍTULO 22

flotado [] getLocation () (
flotado [] = new loc flotar [2];
loc [0] = initialLocation [0] + currentLocation [0];
loc [1] = initialLocation [2] + currentLocation [1];
loc retorno;
)

Este getLocation () método es un poco difícil. Recordar que el PROTO


examinamos anteriormente contiene dos nodos anidados transformación. El
exterior de una especifica la ubicación inicial de la pieza, y el interior de un
almacena la ubicación actual. También recordar que el interior de una gira en
relación con el exterior uno. El getLocation () método tiene la ubicación inicial
de la pieza en X y Z (almacenados en el [0] y de [2], los elementos de la
segunda initialLocation campo) y se añade la ubicación actual de la pieza en x
e y (almacenados en el [0] y de [1] elementos de la primera currentLocation
campo). La razón por la que no está tanto X e Y o ambas x y z es porque los
dos nodos de transformación se alternan entre sí.

Ya mencionamos el reinicio () el método anterior. , El fichero es llamado por


comenzar () cuando el applet se inicia o se reinicia:

public void reiniciar (navegador navegador,


EventOutObserver observador) (
nodo = null;
while (nodo == null) (
try (browser.getNode = nodo (nombre);)
de capturas (InvalidNodeException e) ()
)
EventOutSFVec3f loc = (EventOutSFVec3f)
node.getEventOut ( "initialLocation");
initialLocation = loc.getValue ();
updateLocation ();
EventOutSFBool isActive = (EventOutSFBool)
node.getEventOut ( "isActive");
isActive.advise (observador, este);
)

El método comienza por preguntar el navegador para buscar el nodo


correspondiente a la pieza, sobre la base de su nombre. Mucho ese nombre
coincide con el nombre que se utilizó en la definición de la pieza en el archivo
VRML.
18

VRML 2.0 con Java CAPÍTULO 22

Es concebible que este método podría ser llamado a comparecer ante el


navegador ha terminado de cargar las piezas, por lo que la DEF nombres aún
no pueden estar disponibles. Por lo tanto, la encuesta del navegador hasta que
el nodo se encuentra, haciendo caso omiso de la captura y
InvalidNodeExceptions.

Una vez que haya una referencia al nodo, el método es la initialLocation y pide
updateLocation () para obtener un valor inicial para la currentLocation.

A continuación se encuentra la isActive eventOut y utiliza el asesoramiento ()


para establecer un método EventOutObserver sobre el mismo. Cuando el valor
del campo isActive cambios, el evento se transmitirá a la devolución de
llamada () el método de observador objeto. El observador en este caso es el
applet en sí mismo, y los datos del usuario que se pasa a la llamada se hace
referencia a la pieza misma. Así es como la de devolución de llamada () sabe
que el método fue movido pieza.

El updateLocation () sea el método utilizado para obtener la ubicación actual


de la pieza desde el navegador:

public void updateLocation () (


EventOutSFVec3f loc = (EventOutSFVec3f)
node.getEventOut ( "location_changed");
currentLocation = loc.getValue ();
)

Simplemente lee el valor actual de la location_changed eventOut.


Juntando Todo

Ahora que nuestro applet es terminado, el paso final es combinar con el tablero
y las piezas. Hacemos esto por poner juntos en la misma página HTML:

<html>
<head>
<title> Ajedrez </ title>
</ head>

<embed src="chess.wrl" border=1 height=300 width=500>


<applet code="chess.class" mayscript> </ applet>

</ html>

La etiqueta EMBED chess.wrl pone el archivo en la página en un 300-por-500


19

VRML 2.0 con Java CAPÍTULO 22

ventana. La etiqueta de applet chess.class carga el archivo. Tenga en cuenta


que no especifica ninguna dimensión, ya que el applet no ocupa toda la
pantalla de bienes raíces.
Orientación futura

El mundo y VRML applet que aquí se presentan son sólo un punto, por
supuesto. El siguiente paso sería añadir una pieza a la PositionInterpolator
PROTO para permitir que las piezas a ser trasladada bajo el control de la
aplicación. El applet que llenar en la primera y última entradas en el campo
keyValue de la interpolador, startTime y el valor de un TimeSensor que sería
dirigida a impulsar el interpolador. El interpolador value_changed del campo se
encaminan hacia el set_translation ámbito de la transformación interna de la
PROTO.

En ese momento, hay varias formas en que el código podría ser utilizado. Por
ejemplo, un completo juego de ajedrez se podrían aplicar en Java y se utilizan
para jugar contra el usuario. Como alternativa, un programa de ajedrez escrito
en C (como gnuchess) podría aplicarse como un conjunto de métodos nativos
que el applet de Java que llamar.

Alternativamente, un servidor multiusuario podría utilizarse para permitir que


dos usuarios juegan unos contra otros o jugar contra un usuario remoto un
programa de ajedrez. El software del servidor de ajedrez de Internet podría ser
un buen punto de partida para ello.

I provisionalmente plan para seguir desarrollando el programa de ajedrez en


los próximos meses. Asegúrese de verificar mi sitio web
(http://ece.uwaterloo.ca/ ~ broehl / vrml /) para la última versión.