home *** CD-ROM | disk | FTP | other *** search
/ IRIX 6.5 Applications 2004 May / SGI IRIX 6.5 Applications 2004 May.iso / dist / java3d.idb / usr / demos / java / j3d / programs / examples / FourByFour / Positions.java.z / Positions.java
Encoding:
Java Source  |  2003-08-08  |  9.8 KB  |  307 lines
  1. /*
  2.  *    @(#)Positions.java 1.13 02/04/01 15:03:31
  3.  *
  4.  * Copyright (c) 1996-2002 Sun Microsystems, Inc. All Rights Reserved.
  5.  *
  6.  * Redistribution and use in source and binary forms, with or without
  7.  * modification, are permitted provided that the following conditions
  8.  * are met:
  9.  *
  10.  * - Redistributions of source code must retain the above copyright
  11.  *   notice, this list of conditions and the following disclaimer.
  12.  *
  13.  * - Redistribution in binary form must reproduce the above copyright
  14.  *   notice, this list of conditions and the following disclaimer in
  15.  *   the documentation and/or other materials provided with the
  16.  *   distribution.
  17.  *
  18.  * Neither the name of Sun Microsystems, Inc. or the names of
  19.  * contributors may be used to endorse or promote products derived
  20.  * from this software without specific prior written permission.
  21.  *
  22.  * This software is provided "AS IS," without a warranty of any
  23.  * kind. ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND
  24.  * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY,
  25.  * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY
  26.  * EXCLUDED. SUN AND ITS LICENSORS SHALL NOT BE LIABLE FOR ANY DAMAGES
  27.  * SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
  28.  * DISTRIBUTING THE SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN
  29.  * OR ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR
  30.  * FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR
  31.  * PUNITIVE DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF
  32.  * LIABILITY, ARISING OUT OF THE USE OF OR INABILITY TO USE SOFTWARE,
  33.  * EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
  34.  *
  35.  * You acknowledge that Software is not designed,licensed or intended
  36.  * for use in the design, construction, operation or maintenance of
  37.  * any nuclear facility.
  38.  */
  39.  
  40. import java.applet.Applet;
  41. import java.awt.event.*;
  42. import javax.media.j3d.*;
  43. import javax.vecmath.*;
  44. import java.util.BitSet;
  45. import com.sun.j3d.utils.geometry.Sphere;
  46.  
  47. /**
  48.  * Class:       Positions
  49.  *
  50.  * Description: Creates the position markers.
  51.  *
  52.  * Version:     1.0
  53.  *
  54.  */
  55. public class Positions extends Object {
  56.  
  57.    final static int UNOCCUPIED = 0;
  58.    final static int HUMAN      = 1;
  59.    final static int MACHINE    = 2;
  60.    final static int END        = 3;
  61.  
  62.    private Vector3f point[];
  63.    private Switch posSwitch;
  64.    private Switch humanSwitch;
  65.    private Switch machineSwitch;
  66.    private BitSet posMask;
  67.    private BitSet humanMask;
  68.    private BitSet machineMask;
  69.    private Group group;
  70.    private Material redMat;
  71.    private Material blueMat;
  72.    private Material yellowMat;
  73.    private Material whiteMat;
  74.    private Appearance redApp;
  75.    private Appearance blueApp;
  76.    private Appearance yellowApp;
  77.    private Appearance whiteApp;
  78.    private Board board;
  79.    private Sphere posSphere[];
  80.    private BigCube cube[];
  81.    private TransformGroup tgroup;
  82.    private boolean winnerFlag = false;
  83.  
  84.    public Positions() {
  85.  
  86.       // Define colors for lighting
  87.       Color3f white     = new Color3f(1.0f, 1.0f, 1.0f);
  88.       Color3f black     = new Color3f(0.0f, 0.0f, 0.0f);
  89.       Color3f red       = new Color3f(0.9f, 0.1f, 0.2f);
  90.       Color3f blue      = new Color3f(0.3f, 0.3f, 0.8f);
  91.       Color3f yellow    = new Color3f(1.0f, 1.0f, 0.0f);
  92.       Color3f ambRed    = new Color3f(0.3f, 0.03f, 0.03f);
  93.       Color3f ambBlue   = new Color3f(0.03f, 0.03f, 0.3f);
  94.       Color3f ambYellow = new Color3f(0.3f, 0.3f, 0.03f);
  95.       Color3f ambWhite  = new Color3f(0.3f, 0.3f, 0.3f);
  96.       Color3f specular  = new Color3f(1.0f, 1.0f, 1.0f);
  97.  
  98.       // Create the red appearance node
  99.       redMat= new Material(ambRed, black, red, specular, 100.f);
  100.       redMat.setLightingEnable(true);
  101.       redApp = new Appearance();
  102.       redApp.setMaterial(redMat);
  103.  
  104.       // Create the blue appearance node
  105.       blueMat= new Material(ambBlue, black, blue, specular, 100.f);
  106.       blueMat.setLightingEnable(true);
  107.       blueApp = new Appearance();
  108.       blueApp.setMaterial(blueMat);
  109.  
  110.       // Create the yellow appearance node
  111.       yellowMat= new Material(ambYellow, black, yellow, specular, 100.f);
  112.       yellowMat.setLightingEnable(true);
  113.       yellowApp = new Appearance();
  114.       yellowApp.setMaterial(yellowMat);
  115.  
  116.       // Create the white appearance node
  117.       whiteMat= new Material(ambWhite, black, white, specular, 100.f);
  118.       whiteMat.setLightingEnable(true);
  119.       whiteApp = new Appearance();
  120.       whiteApp.setMaterial(whiteMat);
  121.  
  122.       // Load the point array with the offset (coordinates) for each of 
  123.       // the 64 positions.
  124.       point = new Vector3f[64];
  125.       int count = 0;
  126.       for (int i=-30; i<40; i+=20) {
  127.          for (int j=-30; j<40; j+=20) {
  128.             for (int k=-30; k<40; k+=20) {
  129.                point[count] = new Vector3f((float) k, (float) j, (float) i);
  130.                count++;
  131.             }
  132.          }
  133.       }
  134.  
  135.       // Create the switch nodes
  136.       posSwitch = new Switch(Switch.CHILD_MASK);
  137.       humanSwitch = new Switch(Switch.CHILD_MASK);
  138.       machineSwitch = new Switch(Switch.CHILD_MASK);
  139.  
  140.       // Set the capability bits
  141.       posSwitch.setCapability(Switch.ALLOW_SWITCH_READ);
  142.       posSwitch.setCapability(Switch.ALLOW_SWITCH_WRITE);
  143.  
  144.       humanSwitch.setCapability(Switch.ALLOW_SWITCH_READ);
  145.       humanSwitch.setCapability(Switch.ALLOW_SWITCH_WRITE);
  146.       
  147.       machineSwitch.setCapability(Switch.ALLOW_SWITCH_READ);
  148.       machineSwitch.setCapability(Switch.ALLOW_SWITCH_WRITE);
  149.       
  150.       // Create the bit masks
  151.       posMask = new BitSet();  
  152.       humanMask = new BitSet();  
  153.       machineMask = new BitSet();  
  154.  
  155.       // Create the small white spheres that mark unoccupied
  156.       // positions.
  157.       posSphere = new Sphere[64];
  158.       for (int i=0; i<64; i++) {
  159.          Transform3D transform3D = new Transform3D();
  160.          transform3D.set(point[i]);
  161.          TransformGroup transformGroup = new TransformGroup(transform3D);
  162.          posSphere[i] = new Sphere(2.0f, Sphere.GENERATE_NORMALS |
  163.                    Sphere.ENABLE_APPEARANCE_MODIFY,
  164.                    12, whiteApp);
  165.          Shape3D shape = posSphere[i].getShape(); 
  166.          ID id = new ID(i);
  167.          shape.setUserData(id); 
  168.          transformGroup.addChild(posSphere[i]);
  169.          posSwitch.addChild(transformGroup);
  170.          posMask.set(i);
  171.       }
  172.  
  173.       // Create the red spheres that mark the user's positions.
  174.       for (int i=0; i<64; i++) {
  175.          Transform3D transform3D = new Transform3D();
  176.          transform3D.set(point[i]);
  177.          TransformGroup transformGroup = new TransformGroup(transform3D);
  178.          transformGroup.addChild(new Sphere(7.0f, redApp));
  179.          humanSwitch.addChild(transformGroup);
  180.          humanMask.clear(i);
  181.       }
  182.  
  183.       // Create the blue cubes that mark the computer's positions.
  184.       for (int i=0; i<64; i++) {
  185.          Transform3D transform3D = new Transform3D();
  186.          transform3D.set(point[i]);
  187.          TransformGroup transformGroup = new TransformGroup(transform3D);
  188.          BigCube cube = new BigCube(blueApp);
  189.          transformGroup.addChild(cube.getChild());
  190.          machineSwitch.addChild(transformGroup);
  191.          machineMask.clear(i);
  192.       }
  193.  
  194.       // Set the positions mask
  195.       posSwitch.setChildMask(posMask);
  196.       humanSwitch.setChildMask(humanMask);
  197.       machineSwitch.setChildMask(machineMask);
  198.  
  199.       // Throw everything into a single group
  200.       group = new Group();
  201.       group.addChild(posSwitch);
  202.       group.addChild(humanSwitch);
  203.       group.addChild(machineSwitch);
  204.    }
  205.  
  206.    public void setTransformGroup(TransformGroup transformGroup) {
  207.       tgroup = transformGroup;
  208.    }
  209.  
  210.    public Group getChild() {
  211.       return group;
  212.    }
  213.  
  214.    public void setBoard(Board board) {
  215.       this.board = board;
  216.    }
  217.  
  218.    public void winner() {
  219.       winnerFlag = true;
  220.    }
  221.  
  222.    public void noWinner() {
  223.       winnerFlag = false;
  224.    }
  225.  
  226.    public void setHighlight(int pos) {
  227.       posSphere[pos].setAppearance(yellowApp);
  228.    }
  229.  
  230.    public void clearHighlight(int pos) {
  231.       posSphere[pos].setAppearance(whiteApp);
  232.    }
  233.  
  234.    public void newGame() {
  235.  
  236.       // Clear the board
  237.       for (int i=0; i<64; i++) {
  238.          posMask.set(i);
  239.          humanMask.clear(i);
  240.          machineMask.clear(i);
  241.       }
  242.       posSwitch.setChildMask(posMask);
  243.       humanSwitch.setChildMask(humanMask);
  244.       machineSwitch.setChildMask(machineMask);
  245.  
  246.       // The following three lines fix a bug in J3D
  247.       Transform3D t = new Transform3D();
  248.       tgroup.getTransform(t);
  249.       tgroup.setTransform(t);
  250.  
  251.       // Reset the winner flag
  252.       winnerFlag = false;
  253.    }
  254.  
  255.    public void set(int pos, int player) {
  256.  
  257.       // Stop accepting selections when the game
  258.       // is over.
  259.       if (winnerFlag) return;
  260.  
  261.       // Make sure the position is not occupied.
  262.       if (player == HUMAN)
  263.          if (!board.unoccupied(pos)) return;
  264.  
  265.       // Turn off the position marker for the given position
  266.       posMask.clear(pos);
  267.       posSwitch.setChildMask(posMask);
  268.  
  269.       // Turn on the player marker
  270.       if (player == Positions.HUMAN) {
  271.          humanMask.set(pos);
  272.          humanSwitch.setChildMask(humanMask);
  273.          board.selection(pos, Positions.HUMAN);
  274.       }
  275.       else {
  276.          machineMask.set(pos);
  277.          machineSwitch.setChildMask(machineMask);
  278.       }
  279.  
  280.       // The following three lines fix a bug in J3D
  281.       Transform3D t = new Transform3D();
  282.       tgroup.getTransform(t);
  283.       tgroup.setTransform(t);
  284.    }
  285.  
  286.    public void clear(int pos) {
  287.  
  288.       // Turn on the position marker
  289.       posMask.set(pos);
  290.       posSwitch.setChildMask(posMask);
  291.  
  292.       // Turn off the player marker
  293.       humanMask.clear(pos);
  294.       humanSwitch.setChildMask(humanMask);
  295.       machineMask.clear(pos);
  296.       machineSwitch.setChildMask(machineMask);
  297.  
  298.       // The following three lines are a workaround for a bug 
  299.       // in dev09 in which the transform3D of certain items are
  300.       // not updated properly. Scheduled to be fixed in dev10
  301.       Transform3D t = new Transform3D();
  302.       tgroup.getTransform(t);
  303.       tgroup.setTransform(t);
  304.    }
  305.  
  306. }
  307.