home *** CD-ROM | disk | FTP | other *** search
/ Internet Gallery / INTERGAL.bin / intergal / prgs / idv21 / data.z / Maze3D.java < prev    next >
Text File  |  1995-10-08  |  148KB  |  3,654 lines
  1.  
  2. /*
  3.  
  4.         Copyright (c) 1996 James L. Dean
  5.      
  6.         This program may be distributed or used without payment to its author
  7.    so long as the copyright notices are not altered or removed.
  8.  
  9.         The author -- James L. Dean -- can be contacted via Email as
  10.    csvcjld@nomvs.lsumc.edu.
  11.  
  12. */
  13.  
  14. import java.awt.*;
  15. import java.applet.*;
  16. import java.util.Date;
  17.  
  18. public class Maze3D extends Applet
  19.   {
  20.     public  boolean      clearUserAttempts;
  21.     public  boolean      hexagonalRooms;
  22.     private MazeControls mazeControls;
  23.     public  MazeCanvas   mazeCanvas;
  24.     public  TextField    message;
  25.     public  boolean      solutionDisplayed;
  26.     public  double       tilt;
  27.     private Scrollbar    tiltScrollbar;
  28.  
  29.     public void init()
  30.       {
  31.         solutionDisplayed=false;
  32.         setLayout(new BorderLayout());
  33.         Panel CenterPanel=new Panel();
  34.         hexagonalRooms=false;
  35.         mazeCanvas=new MazeCanvas(this);
  36.         add("Center",mazeCanvas);
  37.         mazeControls=new MazeControls(this);
  38.         add("South",mazeControls);
  39.         tilt=45.0;
  40.         tiltScrollbar=new Scrollbar(Scrollbar.VERTICAL,(int) tilt,5,30,60);
  41.         add("East",tiltScrollbar);
  42.         message=new TextField(117);
  43.         message.setEditable(false);
  44.         add("North",message);
  45.         resize(AWidth,AHeight);
  46.         if (hexagonalRooms)
  47.           message.setText("Use Home, Up Arrow, PgUp, End, Down "
  48.            +"Arrow, or PgDn to solve.");
  49.         else
  50.           message.setText("Use the arrow keys to solve.");
  51.       }
  52.  
  53.     public void start()
  54.       {
  55.         mazeControls.enable();
  56.       }
  57.  
  58.     public void stop() 
  59.       {
  60.         mazeControls.disable();
  61.       }
  62.  
  63.     public boolean handleEvent(
  64.       Event ev)
  65.         {
  66.           boolean handled;
  67.           if (ev.target == tiltScrollbar)
  68.             {
  69.               if (! mazeCanvas.p.alreadyPainting)
  70.                 {
  71.                   if ((solutionDisplayed)
  72.                   ||  (mazeCanvas.p.userHasSolved))
  73.                     message.setText("");
  74.                   else
  75.                     if (hexagonalRooms)
  76.                       message.setText("Use Home, Up Arrow, PgUp, End, Down "
  77.                        +"Arrow, or PgDn to solve.");
  78.                     else
  79.                       message.setText("Use the arrow keys to solve.");
  80.                 }
  81.               tilt=(double) (90-tiltScrollbar.getValue());
  82.               mazeCanvas.paint(mazeCanvas.getGraphics());
  83.               handled=true;
  84.             }
  85.           else
  86.             handled=false;
  87.           return handled;
  88.         }
  89.  
  90.     public static void main(String args[])
  91.       {
  92. /*
  93.         If you have AppletFrame.class (available in the Beta 2 release of
  94.         the Javas Developers kit), you can uncomment the next line to have
  95.         this applet run as an application (as well as an applet).
  96. */
  97. //      AppletFrame.startApplet("Maze3D","3D Mazes",args);
  98.       }
  99.   }
  100.  
  101. class MazeControls extends Panel
  102.   {
  103.     Checkbox   hexagonalRoomsCheckbox;
  104.     Maze3D     maze3D;
  105.     Checkbox   squareRoomsCheckbox;
  106.  
  107.     public MazeControls(Maze3D maze3D) 
  108.       {
  109.         this.maze3D=maze3D;
  110.         add(new Button("New"));
  111.         add(new Button("Solve"));
  112.         add(new Button("Clear"));
  113.         hexagonalRoomsCheckbox
  114.          =new Checkbox("Hexagonal rooms");
  115.         hexagonalRoomsCheckbox.setState(maze3D.hexagonalRooms);
  116.         add("South",hexagonalRoomsCheckbox);
  117.         squareRoomsCheckbox=new Checkbox("Square rooms");
  118.         squareRoomsCheckbox.setState(! maze3D.hexagonalRooms);
  119.         add("South",squareRoomsCheckbox);
  120.         add(new Button("About"));
  121.       }
  122.  
  123.     public boolean keyDown(
  124.       Event ev,
  125.       int   key)
  126.         {
  127.           boolean handled;
  128.           if (maze3D.mazeCanvas.p.alreadyPainting)
  129.             handled=false;
  130.           else
  131.             if ((maze3D.solutionDisplayed)
  132.             ||  (maze3D.mazeCanvas.p.userHasSolved))
  133.               {
  134.                 maze3D.message.setText("");
  135.                 handled=false;
  136.               }
  137.             else
  138.               {
  139.                 if (maze3D.hexagonalRooms)
  140.                   maze3D.message.setText("Use Home, Up Arrow, PgUp, End, "
  141.                    +"Down Arrow, or PgDn to solve.");
  142.                 else
  143.                   maze3D.message.setText("Use the arrow keys to solve.");
  144.                 if (maze3D.hexagonalRooms)
  145.                   switch (key)
  146.                     {
  147.                       case ev.LEFT:
  148.                         handled=true;
  149.                         break;
  150.                       case (int) '4':
  151.                         handled=true;
  152.                         break;
  153.                       case ev.RIGHT:
  154.                         handled=true;
  155.                         break;
  156.                       case (int) '6':
  157.                         handled=true;
  158.                         break;
  159.                       case ev.UP:
  160.                         maze3D.mazeCanvas.p.hexKey(2);
  161.                         handled=true;
  162.                         break;
  163.                       case (int) '8':
  164.                         maze3D.mazeCanvas.p.hexKey(2);
  165.                         handled=true;
  166.                         break;
  167.                       case ev.DOWN:
  168.                         maze3D.mazeCanvas.p.hexKey(3);
  169.                         handled=true;
  170.                         break;
  171.                       case (int) '2':
  172.                         maze3D.mazeCanvas.p.hexKey(3);
  173.                         handled=true;
  174.                         break;
  175.                       case ev.HOME:
  176.                         maze3D.mazeCanvas.p.hexKey(0);
  177.                         handled=true;
  178.                         break;
  179.                       case (int) '7':
  180.                         maze3D.mazeCanvas.p.hexKey(0);
  181.                         handled=true;
  182.                         break;
  183.                       case ev.END:
  184.                         maze3D.mazeCanvas.p.hexKey(1);
  185.                         handled=true;
  186.                         break;
  187.                       case (int) '1':
  188.                         maze3D.mazeCanvas.p.hexKey(1);
  189.                         handled=true;
  190.                         break;
  191.                       case ev.PGUP:
  192.                         maze3D.mazeCanvas.p.hexKey(4);
  193.                         handled=true;
  194.                         break;
  195.                       case (int) '9':
  196.                         maze3D.mazeCanvas.p.hexKey(4);
  197.                         handled=true;
  198.                         break;
  199.                       case ev.PGDN:
  200.                         maze3D.mazeCanvas.p.hexKey(5);
  201.                         handled=true;
  202.                         break;
  203.                       case (int) '3':
  204.                         maze3D.mazeCanvas.p.hexKey(5);
  205.                         handled=true;
  206.                         break;
  207.                       default:
  208.                         handled=false;
  209.                         break;
  210.                     }
  211.                 else
  212.                   switch (key)
  213.                     {
  214.                       case ev.LEFT:
  215.                         maze3D.mazeCanvas.p.sqrKey(0);
  216.                         handled=true;
  217.                         break;
  218.                       case (int) '4':
  219.                         maze3D.mazeCanvas.p.sqrKey(0);
  220.                         handled=true;
  221.                         break;
  222.                       case ev.RIGHT:
  223.                         maze3D.mazeCanvas.p.sqrKey(2);
  224.                         handled=true;
  225.                         break;
  226.                       case (int) '6':
  227.                         maze3D.mazeCanvas.p.sqrKey(2);
  228.                         handled=true;
  229.                         break;
  230.                       case ev.UP:
  231.                         maze3D.mazeCanvas.p.sqrKey(3);
  232.                         handled=true;
  233.                         break;
  234.                       case (int) '8':
  235.                         maze3D.mazeCanvas.p.sqrKey(3);
  236.                         handled=true;
  237.                         break;
  238.                       case ev.DOWN:
  239.                         maze3D.mazeCanvas.p.sqrKey(1);
  240.                         handled=true;
  241.                         break;
  242.                       case (int) '2':
  243.                         maze3D.mazeCanvas.p.sqrKey(1);
  244.                         handled=true;
  245.                         break;
  246.                       case ev.HOME:
  247.                         handled=true;
  248.                         break;
  249.                       case (int) '7':
  250.                         handled=true;
  251.                         break;
  252.                       case ev.END:
  253.                         handled=true;
  254.                         break;
  255.                       case (int) '1':
  256.                         handled=true;
  257.                         break;
  258.                       case ev.PGUP:
  259.                         handled=true;
  260.                         break;
  261.                       case (int) '9':
  262.                         handled=true;
  263.                         break;
  264.                       case ev.PGDN:
  265.                         handled=true;
  266.                         break;
  267.                       case (int) '3':
  268.                         handled=true;
  269.                         break;
  270.                       default:
  271.                         handled=false;
  272.                         break;
  273.                     }
  274.                 if (maze3D.mazeCanvas.p.userHasSolved)
  275.                   maze3D.message.setText("Congratulations!");
  276.               }
  277.           return handled;
  278.         }
  279.  
  280.     public boolean action(
  281.       Event ev,
  282.       Object arg)
  283.         {
  284.           boolean handled;
  285.           if (ev.target instanceof Button)
  286.             {
  287.               String label=(String) arg;
  288.               if (label.equals("New"))
  289.                 {
  290.                   maze3D.solutionDisplayed=false;
  291.                   maze3D.mazeCanvas.previousHeight=0;
  292.                   maze3D.mazeCanvas.previousWidth=0;
  293.                   maze3D.mazeCanvas.paint(maze3D.mazeCanvas.getGraphics());
  294.                 }
  295.               else if (label.equals("Solve"))
  296.                 {
  297.                   maze3D.message.setText("");
  298.                   maze3D.solutionDisplayed=true;
  299.                   if (maze3D.mazeCanvas.p.alreadyPainting)
  300.                     maze3D.mazeCanvas.paint(
  301.                      maze3D.mazeCanvas.getGraphics());
  302.                   else
  303.                     if (maze3D.hexagonalRooms)
  304.                       maze3D.mazeCanvas.p.hexDisplaySolution();
  305.                     else
  306.                       maze3D.mazeCanvas.p.sqrDisplaySolution();
  307.                 }
  308.               else if (label.equals("Clear"))
  309.                 {
  310.                   if (maze3D.hexagonalRooms)
  311.                     maze3D.message.setText("Use Home, Up Arrow, PgUp, End, "
  312.                      +"Down Arrow, or PgDn to solve.");
  313.                   else
  314.                     maze3D.message.setText("Use the arrow keys to solve.");
  315.                   maze3D.solutionDisplayed=false;
  316.                   maze3D.clearUserAttempts=true;
  317.                   maze3D.mazeCanvas.paint(
  318.                    maze3D.mazeCanvas.getGraphics());
  319.                 }
  320.               else
  321.                 {
  322.                   if (label.equals("About"))
  323.                     maze3D.message.setText(
  324.                      "Copyright (c) 1996 James L. Dean.  This program may be "
  325.                      +"distributed or used without payment to its author.");
  326.                 }
  327.               handled=true;
  328.             }
  329.           else if (ev.target == hexagonalRoomsCheckbox)
  330.             {
  331.               squareRoomsCheckbox.setState(false);
  332.               hexagonalRoomsCheckbox.setState(true);
  333.               if (! maze3D.hexagonalRooms)
  334.                 {
  335.                   maze3D.hexagonalRooms=true;
  336.                   maze3D.solutionDisplayed=false;
  337.                   maze3D.mazeCanvas.previousHeight=0;
  338.                   maze3D.mazeCanvas.previousWidth=0;
  339.                   maze3D.mazeCanvas.paint(
  340.                    maze3D.mazeCanvas.getGraphics());
  341.                 }
  342.               handled=true;
  343.             }
  344.           else if (ev.target == squareRoomsCheckbox)
  345.             {
  346.               squareRoomsCheckbox.setState(true);
  347.               hexagonalRoomsCheckbox.setState(false);
  348.               if (maze3D.hexagonalRooms)
  349.                 {
  350.                   maze3D.hexagonalRooms=false;
  351.                   maze3D.solutionDisplayed=false;
  352.                   maze3D.mazeCanvas.previousHeight=0;
  353.                   maze3D.mazeCanvas.previousWidth=0;
  354.                   maze3D.mazeCanvas.paint(
  355.                    maze3D.mazeCanvas.getGraphics());
  356.                 }
  357.               handled=true;
  358.             }
  359.           else
  360.             handled=false;
  361.           return handled;
  362.         }
  363.   }
  364.  
  365. class MazeCanvas extends Canvas
  366.   {
  367.     private boolean     invalidated;
  368.     public  Maze3D      maze3D;
  369.     public  PaintScreen p;
  370.     public  int         previousHeight;
  371.     public  int         previousWidth;
  372.     public  Rectangle   rectangle;
  373.     public  boolean     resize;
  374.           
  375.     MazeCanvas(Maze3D maze3D)
  376.       {
  377.         this.maze3D=maze3D;
  378.         invalidated=false;
  379.         previousWidth=0;
  380.         previousHeight=0;
  381.         p=new PaintScreen(this);
  382.         p.start();
  383.       }
  384.  
  385.     public void paint(Graphics g)
  386.       {
  387.         if (invalidated)
  388.           {
  389.             invalidated=false;
  390.             rectangle=bounds();
  391.             if ((previousWidth == rectangle.width) 
  392.             &&  (previousHeight == rectangle.height))
  393.               resize=false;
  394.             else
  395.               {
  396.                 if (maze3D.hexagonalRooms)
  397.                   maze3D.message.setText("Use Home, Up Arrow, PgUp, End, "
  398.                    +"Down Arrow, or PgDn to solve.");
  399.                 else
  400.                   maze3D.message.setText("Use the arrow keys to solve.");
  401.                 maze3D.solutionDisplayed=false;
  402.                 resize=true;
  403.                 previousWidth=rectangle.width;
  404.                 previousHeight=rectangle.height;
  405.               }
  406.             p.restart=true;
  407.           }
  408.         else
  409.           {
  410.             invalidated=true;
  411.             hide();
  412.             show();
  413.           }
  414.       }
  415.   }
  416.  
  417. class VertexRec
  418.   {
  419.     double x;
  420.     double y;
  421.  
  422.     VertexRec()
  423.       {
  424.         x=0.0;
  425.         y=0.0;
  426.       }
  427.   }
  428.     
  429. class StackRec
  430.   {
  431.     short index1;
  432.     short index2;
  433.  
  434.     StackRec()
  435.       {
  436.         index1=(short) 0;
  437.         index2=(short) 0;
  438.       }
  439.   }
  440.   
  441. class POINT
  442.   {
  443.     int x;
  444.     int y;
  445.  
  446.     POINT()
  447.       {
  448.         x=0;
  449.         y=0;
  450.       }
  451.   }
  452.  
  453. class PaintScreen extends Thread
  454.   {
  455.     static private final int       NUM_COLORS                 = 16;
  456.     static private final int       TOP_COLOR                  = 12; 
  457.       /* all but last 3 colors are gray */
  458.     static private final int       RECTANGLE_SE_NW_COLOR      = 10;
  459.     static private final int       TRIANGLE_SSE_NNW_COLOR     =  9;
  460.     static private final int       TRIANGLE_SE_NW_COLOR       =  8;
  461.     static private final int       RECTANGLE_W_E_COLOR        =  7;
  462.     static private final int       FLOOR_COLOR                =  6;
  463.     static private final int       TRIANGLE_SW_NE_COLOR       =  5;
  464.     static private final int       RECTANGLE_SW_NE_COLOR      =  4;
  465.     static private final int       TRIANGLE_SSW_NNE_COLOR     =  3;
  466.     static private final int       BACKOUT_COLOR              = 13;
  467.     static private final int       ADVANCE_COLOR              = 14;
  468.     static private final int       SOLUTION_COLOR             = 15;
  469.     static private final double    RELATIVE_WIDTH_OF_WALL     = 0.25;
  470.       /* relative to side of hexagon or square */
  471.     static private final double    RELATIVE_HEIGHT_OF_WALL    = 2.0; 
  472.       /* relative to side of hexagon or square */
  473.     static private final double    MIN_WALL_LENGTH_IN_INCHES  = 0.25;
  474.     static private final double    SECONDS_FOR_MAZE_SELECTION = 0.25;
  475.     static private final int       SUBSTITUTION_HIGH [] =
  476.                   { 4,1,2,8,8,9,9,6,5,7,2,1,2,9,8,8,6,3,5,1,9,5,4,4,9,8,6,
  477.                     0,8,0,6,0,2,4,1,9,2,0,7,4,7,3,0,0,2,6,8,9,4,0,8,3,2,3,
  478.                     2,5,2,4,6,9,7,9,1,3,5,7,1,1,4,5,8,1,6,0,5,7,8,2,3,3,7,
  479.                     3,5,1,7,5,4,0,3,6,3,7,7,1,9,4,0,5,6,6
  480.                   };
  481.     static private final int       SUBSTITUTION_LOW [] =
  482.                   { 1,2,2,1,5,5,4,6,4,6,4,4,5,6,6,3,0,9,6,5,7,2,0,9,3,4,2,
  483.                     3,9,1,9,9,9,3,8,9,3,4,1,5,0,5,2,7,0,8,8,0,4,5,0,3,6,8,
  484.                     1,7,8,8,7,1,3,2,7,7,1,8,0,3,7,5,2,6,4,0,9,9,7,7,4,6,2,
  485.                     0,0,1,7,3,6,6,1,1,2,4,5,9,8,2,8,8,3,5
  486.                   };
  487.  
  488.     private int        adjacency;
  489.     public  boolean    alreadyPainting;
  490.     private VertexRec  baseRectangle [] [];
  491.     private VertexRec  baseTriangle [] [];
  492.     private boolean    clearUserAttempts;
  493.     private char       computerPage [] [];
  494.     private double     cosTilt;
  495.     private int        counter0;
  496.     private int        counter1;
  497.     private int        counter2;
  498.     private int        counter3;
  499.     private int        counter4;
  500.     private int        counter5;
  501.     private int        counter6;
  502.     private int        counter7;
  503.     private Graphics   graph;
  504.     private boolean    hexagonalRooms;
  505.     private int        hexDeltaX [] [];
  506.     private int        hexDeltaY [] [];
  507.     private int        maxX;
  508.     private int        maxY;
  509.     private MazeCanvas mazeCanvas;
  510.     private boolean    minimized;
  511.     private int        numColumns;
  512.     private int        numRoomsInMaze;
  513.     private int        numRoomsInSolution;
  514.     private int        numRows;
  515.     private boolean    paint;
  516.     private double     pixelsPerX;
  517.     private double     pixelsPerZ;
  518.     public  VertexRec  rectangle [] [];
  519.     private Color      redGreenBlue []; 
  520.     private double     relDistOfUserFromScreen;
  521.     private boolean    resize;
  522.     public  boolean    restart;
  523.     private Rectangle  screen;
  524.     private int        seed [];
  525.     private double     sinTilt;
  526.     private boolean    solutionDisplayed;
  527.     private int        sqrDeltaX [] [];
  528.     private int        sqrDeltaY [] [];
  529.     private double     sqrt3;
  530.     private StackRec   stack [];
  531.     public  int        state;
  532.     private double     tilt;
  533.     public  boolean    userHasSolved;
  534.     private char       userPage [] [];
  535.     private int        userX;
  536.     private double     userXRelative;
  537.     private int        userY;
  538.     private double     userYRelative;
  539.     private int        x;
  540.     private double     xMax;
  541.     private double     xOffset;
  542.     private int        y;
  543.     private double     yMax;
  544.     private int        yMod4;
  545.     private double     yOffset;
  546.  
  547.     PaintScreen(MazeCanvas mazeCanvas)
  548.       {
  549.         int  colorNum;
  550.         int  deltaIndex1a;
  551.         int  deltaIndex1b;
  552.         int  deltaIndex1c;
  553.         int  deltaIndex1d;
  554.         int  deltaIndex1e;
  555.         int  deltaIndex1f;
  556.         int  deltaIndex2;
  557.         int  objectNum;
  558.         int  tint;
  559.         int  vertexNum;
  560.  
  561.         setDaemon(true);
  562.         this.mazeCanvas=mazeCanvas;
  563.         restart=false;
  564.         hexagonalRooms=this.mazeCanvas.maze3D.hexagonalRooms;
  565.         clearUserAttempts=true;
  566.         state=5;
  567.         baseRectangle=new VertexRec [6] [4];
  568.         for (objectNum=0; objectNum < 6; ++objectNum)
  569.           for (vertexNum=0; vertexNum < 4; ++vertexNum)
  570.             baseRectangle[objectNum][vertexNum]
  571.              =new VertexRec();
  572.         rectangle=new VertexRec [6] [4];
  573.         for (objectNum=0; objectNum < 6; ++objectNum)
  574.           for (vertexNum=0; vertexNum < 4; ++vertexNum)
  575.             rectangle[objectNum][vertexNum]
  576.              =new VertexRec();
  577.         baseTriangle=new VertexRec [4] [3];
  578.         for (objectNum=0; objectNum < 4; ++objectNum)
  579.           for (vertexNum=0; vertexNum < 3; ++vertexNum)
  580.             baseTriangle[objectNum][vertexNum]
  581.              =new VertexRec();
  582.         hexDeltaX=new int [6] [720];
  583.         hexDeltaY=new int [6] [720];
  584.         sqrDeltaX=new int [4] [24];
  585.         sqrDeltaY=new int [4] [24];
  586.         redGreenBlue=new Color[16];
  587.         computerPage=null;
  588.         userPage=null;
  589.         stack=null;
  590.         alreadyPainting=false;
  591.         solutionDisplayed=false;
  592.         userHasSolved=false;
  593.         minimized=false;
  594.  
  595.         hexDeltaY[0][0]=-1;
  596.         hexDeltaX[0][0]=-2;
  597.         hexDeltaY[1][0]=1;
  598.         hexDeltaX[1][0]=-2;
  599.         hexDeltaY[2][0]=-2;
  600.         hexDeltaX[2][0]=0;
  601.         hexDeltaY[3][0]=2;
  602.         hexDeltaX[3][0]=0;
  603.         hexDeltaY[4][0]=-1;
  604.         hexDeltaX[4][0]=2;
  605.         hexDeltaY[5][0]=1;
  606.         hexDeltaX[5][0]=2;
  607.         deltaIndex2=0;
  608.         for (deltaIndex1a=0; deltaIndex1a < 6;
  609.          ++deltaIndex1a)
  610.           for (deltaIndex1b=0; deltaIndex1b < 6;
  611.            ++deltaIndex1b)
  612.             if (deltaIndex1a != deltaIndex1b)
  613.               for (deltaIndex1c=0; deltaIndex1c < 6; ++deltaIndex1c)
  614.                 if ((deltaIndex1a != deltaIndex1c) 
  615.                 &&  (deltaIndex1b != deltaIndex1c))
  616.                   for (deltaIndex1d=0; deltaIndex1d < 6; ++deltaIndex1d)
  617.                     if ((deltaIndex1a != deltaIndex1d)
  618.                     &&  (deltaIndex1b != deltaIndex1d) 
  619.                     &&  (deltaIndex1c != deltaIndex1d))
  620.                       for (deltaIndex1e=0; deltaIndex1e < 6; ++deltaIndex1e)
  621.                         if ((deltaIndex1a != deltaIndex1e) 
  622.                         &&  (deltaIndex1b != deltaIndex1e) 
  623.                         &&  (deltaIndex1c != deltaIndex1e)
  624.                         &&  (deltaIndex1d != deltaIndex1e))
  625.                           for (deltaIndex1f=0; deltaIndex1f < 6; ++deltaIndex1f)
  626.                             if ((deltaIndex1a != deltaIndex1f)
  627.                             && (deltaIndex1b != deltaIndex1f)
  628.                             && (deltaIndex1c != deltaIndex1f)
  629.                             && (deltaIndex1d != deltaIndex1f) 
  630.                             && (deltaIndex1e != deltaIndex1f))
  631.                               {
  632.                                 hexDeltaX[deltaIndex1a][deltaIndex2]
  633.                                  =hexDeltaX[0][0];
  634.                                 hexDeltaY[deltaIndex1a][deltaIndex2]
  635.                                  =hexDeltaY[0][0];
  636.                                 hexDeltaX[deltaIndex1b][deltaIndex2]
  637.                                  =hexDeltaX[1][0];
  638.                                 hexDeltaY[deltaIndex1b][deltaIndex2]
  639.                                  =hexDeltaY[1][0];
  640.                                 hexDeltaX[deltaIndex1c][deltaIndex2]
  641.                                  =hexDeltaX[2][0];
  642.                                 hexDeltaY[deltaIndex1c][deltaIndex2]
  643.                                  =hexDeltaY[2][0];
  644.                                 hexDeltaX[deltaIndex1d][deltaIndex2]
  645.                                  =hexDeltaX[3][0];
  646.                                 hexDeltaY[deltaIndex1d][deltaIndex2]
  647.                                  =hexDeltaY[3][0];
  648.                                 hexDeltaX[deltaIndex1e][deltaIndex2]
  649.                                  =hexDeltaX[4][0];
  650.                                 hexDeltaY[deltaIndex1e][deltaIndex2]
  651.                                  =hexDeltaY[4][0];
  652.                                 hexDeltaX[deltaIndex1f][deltaIndex2]
  653.                                  =hexDeltaX[5][0];
  654.                                 hexDeltaY[deltaIndex1f][deltaIndex2++]
  655.                                  =hexDeltaY[5][0];
  656.                               }
  657.         sqrDeltaY[0][0]=0;
  658.         sqrDeltaX[0][0]=-1;
  659.         sqrDeltaY[1][0]=1;
  660.         sqrDeltaX[1][0]=0;
  661.         sqrDeltaY[2][0]=0;
  662.         sqrDeltaX[2][0]=1;
  663.         sqrDeltaY[3][0]=-1;
  664.         sqrDeltaX[3][0]=0;
  665.         deltaIndex2=0;
  666.         for (deltaIndex1a=0; deltaIndex1a < 4; ++deltaIndex1a)
  667.           for (deltaIndex1b=0; deltaIndex1b < 4; ++deltaIndex1b)
  668.             if (deltaIndex1a != deltaIndex1b)
  669.               for (deltaIndex1c=0; deltaIndex1c < 4; ++deltaIndex1c)
  670.                 if ((deltaIndex1a != deltaIndex1c) 
  671.                 &&  (deltaIndex1b != deltaIndex1c))
  672.                   for (deltaIndex1d=0; deltaIndex1d < 4; ++deltaIndex1d)
  673.                     if ((deltaIndex1a != deltaIndex1d)
  674.                     &&  (deltaIndex1b != deltaIndex1d) 
  675.                     &&  (deltaIndex1c != deltaIndex1d))
  676.                       {
  677.                         sqrDeltaX[deltaIndex1a][deltaIndex2]=sqrDeltaX[0][0];
  678.                         sqrDeltaY[deltaIndex1a][deltaIndex2]=sqrDeltaY[0][0];
  679.                         sqrDeltaX[deltaIndex1b][deltaIndex2]=sqrDeltaX[1][0];
  680.                         sqrDeltaY[deltaIndex1b][deltaIndex2]=sqrDeltaY[1][0];
  681.                         sqrDeltaX[deltaIndex1c][deltaIndex2]=sqrDeltaX[2][0];
  682.                         sqrDeltaY[deltaIndex1c][deltaIndex2]=sqrDeltaY[2][0];
  683.                         sqrDeltaX[deltaIndex1d][deltaIndex2]=sqrDeltaX[3][0];
  684.                         sqrDeltaY[deltaIndex1d][deltaIndex2++]=sqrDeltaY[3][0];
  685.                       }
  686.         sqrt3=Math.sqrt(3.0);
  687.         for (colorNum=0; colorNum <= NUM_COLORS-4; ++colorNum)
  688.           {
  689.             /* evenly spaced shades of gray */
  690.             tint=(256*colorNum)/(NUM_COLORS-3);
  691.             redGreenBlue[colorNum]=new Color(tint,tint,tint);
  692.           }
  693.         redGreenBlue[BACKOUT_COLOR]=new Color(255,255,0);
  694.         redGreenBlue[ADVANCE_COLOR]=new Color(0,255,0);
  695.         redGreenBlue[SOLUTION_COLOR]=new Color(255,0,0);
  696.       }
  697.  
  698.     private void drawQuadrilateral(
  699.       POINT Box [],
  700.       int   colorNum)
  701.         {
  702.           int i;
  703.           int x [];
  704.           int y [];
  705.  
  706.           x=new int [4];
  707.           y=new int [4];
  708.           for (i=0; i < 4; ++i)
  709.             {
  710.               x[i]=Box[i].x;
  711.               y[i]=Box[i].y;
  712.             }
  713.           graph.setColor(redGreenBlue[colorNum]);
  714.           graph.fillPolygon(x,y,4);
  715.           return;
  716.         }
  717.  
  718.     private POINT getCorner(
  719.       double    x,
  720.       double    y,
  721.       double    z)
  722.         {
  723.           POINT  corner;
  724.           double xAdjusted;
  725.           double yPrime;
  726.           double zAdjusted;
  727.           double zPrime;
  728.  
  729.           yPrime=(yMax-y)*cosTilt-z*sinTilt;
  730.           zPrime=(yMax-y)*sinTilt+z*cosTilt;
  731.           zAdjusted=(yMax/2)+relDistOfUserFromScreen
  732.            *(zPrime-(yMax/2))/(yPrime+relDistOfUserFromScreen);
  733.           xAdjusted=(xMax/2)+relDistOfUserFromScreen
  734.            *(x-(xMax/2))/(yPrime+relDistOfUserFromScreen);
  735.           xAdjusted=xAdjusted+xOffset;
  736.           corner=new POINT();
  737.           corner.x=(int) (pixelsPerX*xAdjusted);
  738.           corner.y=screen.height-(int) (pixelsPerZ*zAdjusted);
  739.           return corner;
  740.         }
  741.  
  742.     private void displayQuadrilateral(
  743.       double x0,
  744.       double y0,
  745.       double z0,
  746.       double x1,
  747.       double y1,
  748.       double z1,
  749.       double x2,
  750.       double y2,
  751.       double z2,
  752.       double x3,
  753.       double y3,
  754.       double z3,
  755.       int    shade)
  756.         {
  757.           int   i;
  758.           POINT quadrilateral [];
  759.     
  760.           quadrilateral=new POINT [4];
  761.           quadrilateral[0]=getCorner(x0,y0,z0);
  762.           quadrilateral[1]=getCorner(x1,y1,z1);
  763.           quadrilateral[2]=getCorner(x2,y2,z2);
  764.           quadrilateral[3]=getCorner(x3,y3,z3);
  765.           drawQuadrilateral(quadrilateral,shade);
  766.           return;
  767.         }
  768.  
  769.     private void drawTriangle(
  770.       POINT box [],
  771.       int   colorNum)
  772.         {
  773.           int i;
  774.           int x [];
  775.           int y [];
  776.  
  777.           x=new int [3];
  778.           y=new int [3];
  779.           for (i=0; i < 3; ++i)
  780.             {
  781.               x[i]=box[i].x;
  782.               y[i]=box[i].y;
  783.             }
  784.           graph.setColor(redGreenBlue[colorNum]);
  785.           graph.fillPolygon(x,y,3);
  786.           return;
  787.         }        
  788.  
  789.     private void displayTriangle(
  790.       double x0,
  791.       double y0,
  792.       double z0,
  793.       double x1,
  794.       double y1,
  795.       double z1,
  796.       double x2,
  797.       double y2,
  798.       double z2,
  799.       int    shade)
  800.         {
  801.           int   i;
  802.           POINT triangle [];
  803.     
  804.           triangle=new POINT [3];
  805.           triangle[0]=getCorner(x0,y0,z0);
  806.           triangle[1]=getCorner(x1,y1,z1);
  807.           triangle[2]=getCorner(x2,y2,z2);
  808.           drawTriangle(triangle,shade);
  809.           return;
  810.         }
  811.  
  812.     private void outputTriangle(
  813.       VertexRec triangle [],
  814.       boolean   firstPass,
  815.       int       faceColor)
  816.         {
  817.           double x0;
  818.           double x1;
  819.           double x2;
  820.           double x3;
  821.           double y0;
  822.           double y1;
  823.           double y2;
  824.           double y3;
  825.     
  826.           if (firstPass)
  827.             {
  828.               if ((triangle[1].x < xMax/2.0) && (triangle[1].x > triangle[0].x))
  829.                 {
  830.                   x0=triangle[2].x;
  831.                   y0=triangle[2].y;
  832.                   x1=triangle[1].x;
  833.                   y1=triangle[1].y;
  834.                   x2=triangle[1].x;
  835.                   y2=triangle[1].y;
  836.                   x3=triangle[2].x;
  837.                   y3=triangle[2].y;
  838.                   displayQuadrilateral(x0,y0,RELATIVE_HEIGHT_OF_WALL,x1,y1,
  839.                    RELATIVE_HEIGHT_OF_WALL,x2,y2,0.0,x3,y3,0.0,
  840.                    TRIANGLE_SSW_NNE_COLOR);
  841.                 }
  842.               if ((triangle[1].x > xMax/2.0) && (triangle[1].x < triangle[2].x))
  843.                 {
  844.                   x0=triangle[1].x;
  845.                   y0=triangle[1].y;
  846.                   x1=triangle[0].x;
  847.                   y1=triangle[0].y;
  848.                   x2=triangle[0].x;
  849.                   y2=triangle[0].y;
  850.                   x3=triangle[1].x;
  851.                   y3=triangle[1].y;
  852.                   displayQuadrilateral(x0,y0,RELATIVE_HEIGHT_OF_WALL,x1,y1,
  853.                    RELATIVE_HEIGHT_OF_WALL,x2,y2,0.0,x3,y3,0.0,
  854.                    TRIANGLE_SSE_NNW_COLOR);
  855.                 }
  856.             }
  857.           else
  858.             {
  859.               x0=triangle[0].x;
  860.               y0=triangle[0].y;
  861.               x1=triangle[2].x;
  862.               y1=triangle[2].y;
  863.               x2=triangle[2].x;
  864.               y2=triangle[2].y;
  865.               x3=triangle[0].x;
  866.               y3=triangle[0].y;
  867.               displayQuadrilateral(x0,y0,RELATIVE_HEIGHT_OF_WALL,
  868.                x1,y1,RELATIVE_HEIGHT_OF_WALL,x2,y2,0.0,x3,y3,0.0,faceColor);
  869.               x0=triangle[0].x;
  870.               y0=triangle[0].y;
  871.               x1=triangle[1].x;
  872.               y1=triangle[1].y;
  873.               x2=triangle[2].x;
  874.               y2=triangle[2].y;
  875.               displayTriangle(x0,y0,RELATIVE_HEIGHT_OF_WALL,
  876.                x1,y1,RELATIVE_HEIGHT_OF_WALL,x2,y2,RELATIVE_HEIGHT_OF_WALL,
  877.                TOP_COLOR);
  878.             }
  879.           return;
  880.         }
  881.  
  882.     private void outputRectangle(
  883.       VertexRec rectangle [],
  884.       int       faceColor)
  885.         {
  886.           double x0;
  887.           double x1;
  888.           double x2;
  889.           double x3;
  890.           double y0;
  891.           double y1;
  892.           double y2;
  893.           double y3;
  894.     
  895.           x0=rectangle[3].x;
  896.           y0=rectangle[3].y;
  897.           x1=rectangle[2].x;
  898.           y1=rectangle[2].y;
  899.           x2=rectangle[2].x;
  900.           y2=rectangle[2].y;
  901.           x3=rectangle[3].x;
  902.           y3=rectangle[3].y;
  903.           displayQuadrilateral(x0,y0,RELATIVE_HEIGHT_OF_WALL,x1,
  904.            y1,RELATIVE_HEIGHT_OF_WALL,x2,y2,0.0,x3,y3,0.0,faceColor);
  905.           x0=rectangle[0].x;
  906.           y0=rectangle[0].y;
  907.           x1=rectangle[1].x;
  908.           y1=rectangle[1].y;
  909.           x2=rectangle[2].x;
  910.           y2=rectangle[2].y;
  911.           x3=rectangle[3].x;
  912.           y3=rectangle[3].y;
  913.           displayQuadrilateral(x0,y0,RELATIVE_HEIGHT_OF_WALL,x1,
  914.            y1,RELATIVE_HEIGHT_OF_WALL,x2,y2,RELATIVE_HEIGHT_OF_WALL,x3,y3,
  915.            RELATIVE_HEIGHT_OF_WALL,TOP_COLOR);
  916.           return;
  917.         }
  918.  
  919.     private void outputLeftRight(
  920.       VertexRec rectangle [])
  921.         {
  922.           double x0;
  923.           double x1;
  924.           double x2;
  925.           double x3;
  926.           double y0;
  927.           double y1;
  928.           double y2;
  929.           double y3;
  930.  
  931.           if (2.0*rectangle[0].x > xMax)
  932.             {
  933.               x0=rectangle[0].x;
  934.               y0=rectangle[0].y;
  935.               x1=rectangle[3].x;
  936.               y1=rectangle[3].y;
  937.               x2=rectangle[3].x;
  938.               y2=rectangle[3].y;
  939.               x3=rectangle[0].x;
  940.               y3=rectangle[0].y;
  941.               displayQuadrilateral(x0,y0,RELATIVE_HEIGHT_OF_WALL,x1,y1,
  942.                RELATIVE_HEIGHT_OF_WALL,x2,y2,0.0,x3,y3,0.0,
  943.                RECTANGLE_SE_NW_COLOR);
  944.             }
  945.           if (2.0*rectangle[1].x < xMax)
  946.             {
  947.               x0=rectangle[2].x;
  948.               y0=rectangle[2].y;
  949.               x1=rectangle[1].x;
  950.               y1=rectangle[1].y;
  951.               x2=rectangle[1].x;
  952.               y2=rectangle[1].y;
  953.               x3=rectangle[2].x;
  954.               y3=rectangle[2].y;
  955.               displayQuadrilateral(x0,y0,RELATIVE_HEIGHT_OF_WALL,x1,y1,
  956.                RELATIVE_HEIGHT_OF_WALL,x2,y2,0.0,x3,y3,0.0,
  957.                RECTANGLE_SW_NE_COLOR);
  958.             }
  959.           return;
  960.         }
  961.  
  962.     private void drawLine(
  963.       double x1,
  964.       double y1,
  965.       double x2,
  966.       double y2)
  967.         {
  968.           int   lineX1;
  969.           int   lineX2;
  970.           int   lineY1;
  971.           int   lineY2;
  972.           POINT tem;
  973.  
  974.           tem=getCorner(x1,y1,RELATIVE_HEIGHT_OF_WALL);
  975.           lineX1=tem.x;
  976.           lineY1=tem.y;
  977.           tem=getCorner(x2,y2,RELATIVE_HEIGHT_OF_WALL);
  978.           lineX2=tem.x;
  979.           lineY2=tem.y;
  980.           graph.drawLine(lineX1,lineY1,lineX2,lineY2);
  981.           return;
  982.         }
  983.  
  984.     private void hash()
  985.       {
  986.         int iteration;
  987.         int seed0;
  988.         int seed1;
  989.         int seed2;
  990.         int seed3;
  991.         int seed4;
  992.         int seed5;
  993.         int seed6;
  994.         int seed7;
  995.         int substitutionIndex;
  996.         int tem0;
  997.         int tem1;
  998.         int tem2;
  999.  
  1000.         seed0=counter0;
  1001.         seed1=counter1;
  1002.         seed2=counter2;
  1003.         seed3=counter3;
  1004.         seed4=counter4;
  1005.         seed5=counter5;
  1006.         seed6=counter6;
  1007.         seed7=counter7;
  1008.         for (iteration=8; iteration > 0; --iteration)
  1009.           {
  1010.             substitutionIndex=10*seed1+seed0;
  1011.             tem0=SUBSTITUTION_LOW[substitutionIndex];
  1012.             tem1=SUBSTITUTION_HIGH[substitutionIndex];
  1013.             substitutionIndex=10*seed3+seed2;
  1014.             seed0=SUBSTITUTION_LOW[substitutionIndex];
  1015.             tem2=SUBSTITUTION_HIGH[substitutionIndex];
  1016.             substitutionIndex=10*seed5+seed4;
  1017.             seed2=SUBSTITUTION_LOW[substitutionIndex];
  1018.             seed1=SUBSTITUTION_HIGH[substitutionIndex];
  1019.             substitutionIndex=10*seed7+seed6;
  1020.             seed5=SUBSTITUTION_LOW[substitutionIndex];
  1021.             seed7=SUBSTITUTION_HIGH[substitutionIndex];
  1022.             seed3=tem0;
  1023.             seed6=tem1;
  1024.             seed4=tem2;
  1025.           }
  1026.         counter0=seed0;
  1027.         counter1=seed1;
  1028.         counter2=seed2;
  1029.         counter3=seed3;
  1030.         counter4=seed4;
  1031.         counter5=seed5;
  1032.         counter6=seed6;
  1033.         counter7=seed7;
  1034.         return;
  1035.       }
  1036.  
  1037.     private void increment() 
  1038.       {
  1039.         int tem;
  1040.  
  1041.         tem=(counter0)+1;
  1042.         if (tem <= 9)
  1043.           counter0=tem;
  1044.         else
  1045.           {
  1046.             counter0=0;
  1047.             tem=(counter1)+1;
  1048.             if (tem <= 9)
  1049.               counter1=tem;
  1050.             else
  1051.               {
  1052.                 counter1=0;
  1053.                 tem=(counter2)+1;
  1054.                 if (tem <= 9)
  1055.                   counter2=tem;
  1056.                 else
  1057.                   {
  1058.                     counter2=0;
  1059.                     tem=(counter3)+1;
  1060.                     if (tem <= 9)
  1061.                       counter3=tem;
  1062.                     else
  1063.                       {
  1064.                         counter3=0;
  1065.                         tem=(counter4)+1;
  1066.                         if (tem <= 9)
  1067.                           counter4=tem;
  1068.                         else
  1069.                           {
  1070.                             counter4=0;
  1071.                             tem=(counter5)+1;
  1072.                             if (tem <= 9)
  1073.                               counter5=tem;
  1074.                             else
  1075.                               {
  1076.                                 counter5=0;
  1077.                                 tem=(counter6)+1;
  1078.                                 if (tem <= 9)
  1079.                                   counter6=tem;
  1080.                                 else
  1081.                                   {
  1082.                                     counter6=0;
  1083.                                     tem=(counter7)+1;
  1084.                                     if (tem <= 9)
  1085.                                       counter7=tem;
  1086.                                     else
  1087.                                       counter7=0;
  1088.                                   }
  1089.                               }
  1090.                           }
  1091.                       }
  1092.                   }
  1093.               }
  1094.           }
  1095.         return;
  1096.       }
  1097.  
  1098.     public void hexKey(
  1099.       int deltaIndex1)
  1100.         {
  1101.           boolean passageFound;
  1102.           int     xNext;
  1103.           double  xRelativeNext;
  1104.           int     yNext;
  1105.           double  yRelativeNext;
  1106.  
  1107.           yNext=0;
  1108.           xRelativeNext=0.0;
  1109.           yRelativeNext=0.0;
  1110.           passageFound=true;
  1111.           xNext=userX+hexDeltaX[deltaIndex1][0];
  1112.           if (xNext <= 0)
  1113.             passageFound=false;
  1114.           else
  1115.             if (xNext >= maxX)
  1116.               passageFound=false;
  1117.             else
  1118.               yNext=userY+hexDeltaY[deltaIndex1][0];
  1119.               if (yNext <= 0)
  1120.                 passageFound=false;
  1121.               else
  1122.                 if (yNext > maxY)
  1123.                   passageFound=false;
  1124.                 else
  1125.                   {
  1126.                     if (userPage[yNext][xNext] == '\000')
  1127.                       passageFound=false;
  1128.                   }
  1129.           if (passageFound)
  1130.             {
  1131.               xNext=xNext+hexDeltaX[deltaIndex1][0];
  1132.               yNext=yNext+hexDeltaY[deltaIndex1][0];
  1133.               if (yNext < maxY)
  1134.                 {
  1135.                   if (userPage[yNext][xNext] == '\001')
  1136.                     {
  1137.                       graph.setColor(redGreenBlue[BACKOUT_COLOR]);
  1138.                       userPage[userY][userX]='\003';
  1139.                     }
  1140.                   else
  1141.                     {
  1142.                       graph.setColor(redGreenBlue[ADVANCE_COLOR]);
  1143.                       userPage[yNext][xNext]='\001';
  1144.                     }
  1145.                   switch (yNext - userY)
  1146.                     {
  1147.                       case -4:
  1148.                         xRelativeNext=userXRelative;
  1149.                         yRelativeNext=userYRelative-sqrt3;
  1150.                         break;
  1151.                       case -2:
  1152.                         if (xNext > userX)
  1153.                           {
  1154.                             xRelativeNext=userXRelative+3.0/2.0;
  1155.                             yRelativeNext=userYRelative-sqrt3/2.0;
  1156.                           }
  1157.                         else
  1158.                           {
  1159.                             xRelativeNext=userXRelative-3.0/2.0;
  1160.                             yRelativeNext=userYRelative-sqrt3/2.0;
  1161.                           }
  1162.                         break;
  1163.                       case 2:
  1164.                         if (xNext > userX)
  1165.                           {
  1166.                             xRelativeNext=userXRelative+3.0/2.0;
  1167.                             yRelativeNext=userYRelative+sqrt3/2.0;
  1168.                           }
  1169.                         else
  1170.                           {
  1171.                             xRelativeNext=userXRelative-3.0/2.0;
  1172.                             yRelativeNext=userYRelative+sqrt3/2.0;
  1173.                           }
  1174.                         break;
  1175.                       default:
  1176.                         xRelativeNext=userXRelative;
  1177.                         yRelativeNext=userYRelative+sqrt3;
  1178.                         break;
  1179.                     }
  1180.                   drawLine(userXRelative,userYRelative,xRelativeNext,
  1181.                    yRelativeNext);
  1182.                 }
  1183.               else
  1184.                 {
  1185.                   graph.setColor(redGreenBlue[ADVANCE_COLOR]);
  1186.                   drawLine(userXRelative,userYRelative,userXRelative,yMax);
  1187.                   userHasSolved=true;
  1188.                 }
  1189.               userX=xNext;
  1190.               userY=yNext;
  1191.               userXRelative=xRelativeNext;
  1192.               userYRelative=yRelativeNext;
  1193.             }
  1194.         }
  1195.  
  1196.     public void hexDisplayUserMoves()
  1197.       {
  1198.         int     deltaIndex;
  1199.         boolean evenRow;
  1200.         int     x;
  1201.         int     xNext;
  1202.         int     xNextNext;
  1203.         double  xRelative;
  1204.         double  xRelativeNext;
  1205.         int     y;
  1206.         int     yNext;
  1207.         int     yNextNext;
  1208.         double  yRelative;
  1209.         double  yRelativeNext;
  1210.  
  1211.         xRelative=0.0;
  1212.         y=2;
  1213.         yRelative=sqrt3/2.0;
  1214.         evenRow=false;
  1215.         while (y < maxY)
  1216.           {
  1217.             if (evenRow)
  1218.               {
  1219.                 x=7;
  1220.                 xRelative=2.5;
  1221.               }
  1222.             else
  1223.               {
  1224.                 x=3;
  1225.                 xRelative=1.0;
  1226.               }
  1227.             while (x < maxX)
  1228.               {
  1229.                 if ((userPage[y][x] == '\001') || (userPage[y][x] == '\003')) 
  1230.                   for (deltaIndex=0; deltaIndex < 6; ++deltaIndex)
  1231.                     {
  1232.                       xNext=x+hexDeltaX[deltaIndex][0];
  1233.                       yNext=y+hexDeltaY[deltaIndex][0];
  1234.                       if (userPage[yNext][xNext] != '\000')
  1235.                         {
  1236.                           if (yNext == 0)
  1237.                             {
  1238.                               graph.setColor(redGreenBlue[ADVANCE_COLOR]);
  1239.                               drawLine(1.0,0.0,xRelative,yRelative);
  1240.                             }
  1241.                           else
  1242.                             if (yNext == maxY)
  1243.                               {
  1244.                                 if (userHasSolved)
  1245.                                   {
  1246.                                     graph.setColor(redGreenBlue[ADVANCE_COLOR]);
  1247.                                     yRelativeNext=yRelative+sqrt3/2.0;
  1248.                                     drawLine(xRelative,yRelative,xRelative,
  1249.                                      yRelativeNext);
  1250.                                   }
  1251.                               }
  1252.                             else
  1253.                               {
  1254.                                 xNextNext=xNext+hexDeltaX[deltaIndex][0];
  1255.                                 if (xNextNext > 0)
  1256.                                   {
  1257.                                     if (xNextNext < maxX)
  1258.                                       {
  1259.                                         yNextNext
  1260.                                          =yNext+hexDeltaY[deltaIndex][0];
  1261.                                         if (yNextNext > 0)
  1262.                                           {
  1263.                                             if (yNextNext < maxY)
  1264.                                               {
  1265.                                                 if ((userPage[yNextNext][
  1266.                                                  xNextNext] == '\001')
  1267.                                                 ||  (userPage[yNextNext][
  1268.                                                  xNextNext] == '\003'))
  1269.                                                   {
  1270.                                                     if (userPage[y][x]
  1271.                                                      == userPage[yNextNext][
  1272.                                                      xNextNext])
  1273.                                                       if (userPage[y][x]
  1274.                                                        == '\001')
  1275.                                                         graph.setColor(
  1276.                                                          redGreenBlue[
  1277.                                                          ADVANCE_COLOR]);
  1278.                                                       else
  1279.                                                         graph.setColor(
  1280.                                                          redGreenBlue[
  1281.                                                          BACKOUT_COLOR]);
  1282.                                                     else
  1283.                                                       graph.setColor(
  1284.                                                        redGreenBlue[
  1285.                                                        BACKOUT_COLOR]);
  1286.                                                     switch (yNext - y)
  1287.                                                       {
  1288.                                                         case -2:
  1289.                                                           xRelativeNext
  1290.                                                            =xRelative;
  1291.                                                           yRelativeNext
  1292.                                                            =yRelative
  1293.                                                            -sqrt3/2.0;
  1294.                                                           break;
  1295.                                                         case -1:
  1296.                                                           if (xNext > x)
  1297.                                                             {
  1298.                                                               xRelativeNext
  1299.                                                                =xRelative
  1300.                                                                +3.0/4.0;
  1301.                                                               yRelativeNext
  1302.                                                                =yRelative
  1303.                                                                -sqrt3/4.0;
  1304.                                                             }
  1305.                                                           else
  1306.                                                             {
  1307.                                                               xRelativeNext
  1308.                                                                =xRelative
  1309.                                                                -3.0/4.0;
  1310.                                                               yRelativeNext
  1311.                                                                =yRelative 
  1312.                                                                -sqrt3/4.0;
  1313.                                                             }
  1314.                                                           break;
  1315.                                                         case 1:
  1316.                                                           if (xNext > x)
  1317.                                                             {
  1318.                                                               xRelativeNext
  1319.                                                                =xRelative
  1320.                                                                +3.0/4.0;
  1321.                                                               yRelativeNext
  1322.                                                                =yRelative
  1323.                                                                +sqrt3/4.0;
  1324.                                                             }
  1325.                                                           else
  1326.                                                             {
  1327.                                                               xRelativeNext
  1328.                                                                =xRelative
  1329.                                                                -3.0/4.0;
  1330.                                                               yRelativeNext
  1331.                                                                =yRelative
  1332.                                                                +sqrt3/4.0;
  1333.                                                             }
  1334.                                                           break;
  1335.                                                         default:
  1336.                                                           xRelativeNext
  1337.                                                            =xRelative;
  1338.                                                           yRelativeNext
  1339.                                                            =yRelative+sqrt3/2.0;
  1340.                                                           break;
  1341.                                                       }
  1342.                                                     drawLine(xRelative,
  1343.                                                      yRelative,xRelativeNext,
  1344.                                                      yRelativeNext);
  1345.                                                   }
  1346.                                                }
  1347.                                           }
  1348.                                       }
  1349.                                   }
  1350.                               }
  1351.                         }
  1352.                     }
  1353.                 xRelative+=3.0;
  1354.                 x+=8;
  1355.               }
  1356.             evenRow=! evenRow;
  1357.             yRelative+=sqrt3/2.0;
  1358.             y+=2;
  1359.           }
  1360.         if (userHasSolved)
  1361.           {
  1362.             graph.setColor(redGreenBlue[ADVANCE_COLOR]);
  1363.             drawLine(xRelative,yRelative,xRelative,yMax);
  1364.           }
  1365.       }
  1366.  
  1367.     private void hexSolveMaze()
  1368.         {
  1369.           int     deltaIndex;
  1370.           boolean passageFound;
  1371.           int     stackHead;
  1372.           int     x;
  1373.           int     xNext;
  1374.           int     y;
  1375.           int     yNext;
  1376.  
  1377.           numRoomsInSolution=1;
  1378.           adjacency=0;
  1379.           x=3;
  1380.           y=2;
  1381.           stackHead=-1;
  1382.           computerPage[y][x]='\001';
  1383.           yNext=0;
  1384.           xNext=0;
  1385.           do
  1386.             {
  1387.               deltaIndex=0;
  1388.               passageFound=false;
  1389.               do
  1390.                 {
  1391.                   while ((deltaIndex < 6) && (! passageFound))
  1392.                     {
  1393.                       xNext=x+hexDeltaX[deltaIndex][0];
  1394.                       yNext=y+hexDeltaY[deltaIndex][0];
  1395.                       if (computerPage[yNext][xNext] == '\002')
  1396.                         passageFound=true;
  1397.                       else
  1398.                         ++deltaIndex;
  1399.                     }
  1400.                   if (! passageFound)
  1401.                     {
  1402.                       deltaIndex=stack[stackHead].index1;
  1403.                       computerPage[y][x]='\002';
  1404.                       x-=hexDeltaX[deltaIndex][0];
  1405.                       y-=hexDeltaY[deltaIndex][0];
  1406.                       computerPage[y][x]='\002';
  1407.                       x-=hexDeltaX[deltaIndex][0];
  1408.                       y-=hexDeltaY[deltaIndex][0];
  1409.                       --stackHead;
  1410.                       ++deltaIndex;
  1411.                     }
  1412.                 }
  1413.               while (! passageFound);
  1414.               computerPage[yNext][xNext]='\001';
  1415.               xNext+=hexDeltaX[deltaIndex][0];
  1416.               yNext+=hexDeltaY[deltaIndex][0];
  1417.               if (yNext <= maxY)
  1418.                 {
  1419.                   stack[++stackHead].index1=(short) deltaIndex;
  1420.                   computerPage[yNext][xNext]='\001';
  1421.                   x=xNext;
  1422.                   y=yNext;
  1423.                 }
  1424.             }
  1425.           while (yNext < maxY);
  1426.           x=maxX-3;
  1427.           y=maxY-2;
  1428.           adjacency=0;
  1429.           while (stackHead >= 0)
  1430.             {
  1431.               for (deltaIndex=0; deltaIndex < 6; ++deltaIndex)
  1432.                 {
  1433.                   xNext=x+hexDeltaX[deltaIndex][0];
  1434.                   yNext=y+hexDeltaY[deltaIndex][0];
  1435.                   if (computerPage[yNext][xNext] != '\001')
  1436.                     {
  1437.                       if (computerPage[yNext][xNext] == '\000')
  1438.                         {
  1439.                           xNext+=hexDeltaX[deltaIndex][0];
  1440.                           yNext+=hexDeltaY[deltaIndex][0];
  1441.                           if (xNext < 0)
  1442.                             ++adjacency;
  1443.                           else
  1444.                             if (xNext > maxX)
  1445.                               ++adjacency;
  1446.                             else
  1447.                               if (yNext < 0)
  1448.                                 ++adjacency;
  1449.                               else
  1450.                                 if (yNext > maxY)
  1451.                                   ++adjacency;
  1452.                                 else
  1453.                                   {
  1454.                                     if (computerPage[yNext][xNext] == '\001')
  1455.                                       ++adjacency;
  1456.                                   }
  1457.                         }
  1458.                     }
  1459.                 }
  1460.               x-=2*hexDeltaX[stack[stackHead].index1][0];
  1461.               y-=2*hexDeltaY[stack[stackHead--].index1][0];
  1462.               ++numRoomsInSolution;
  1463.             }
  1464.           for (deltaIndex=0; deltaIndex < 6; ++deltaIndex)
  1465.             {
  1466.               xNext=x+hexDeltaX[deltaIndex][0];
  1467.               yNext=x+hexDeltaY[deltaIndex][0];
  1468.               if (computerPage[yNext][xNext] != '\002')
  1469.                 {
  1470.                   if (computerPage[yNext][xNext] == '\000')
  1471.                     {
  1472.                       xNext+=hexDeltaX[deltaIndex][0];
  1473.                       yNext+=hexDeltaY[deltaIndex][0];
  1474.                       if (xNext < 0)
  1475.                         ++adjacency;
  1476.                       else
  1477.                         if (xNext > maxX)
  1478.                           ++adjacency;
  1479.                         else
  1480.                           if (yNext < 0)
  1481.                             ++adjacency;
  1482.                           else
  1483.                             if (yNext > maxY)
  1484.                               ++adjacency;
  1485.                             else
  1486.                               {
  1487.                                 if (computerPage[yNext][xNext] == '\001')
  1488.                                   ++adjacency;
  1489.                               }
  1490.                     }
  1491.                 }
  1492.             }
  1493.           return;
  1494.         }
  1495.  
  1496.     private void hexGenerateMaze(
  1497.       int      seed [])
  1498.         {
  1499.           int     columnNum;
  1500.           int     deltaIndex1;
  1501.           int     deltaIndex2;
  1502.           boolean passageFound;
  1503.           int     rN [];
  1504.           int     rNIndex1;
  1505.           int     rNIndex2;
  1506.           int     rowNum;
  1507.           boolean searchComplete;
  1508.           int     stackHead;
  1509.           int     temInt;
  1510.           int     x;
  1511.           int     xMod8;
  1512.           int     xNext;
  1513.           int     y;
  1514.           int     yMod4;
  1515.           int     yNext;
  1516.     
  1517.           yNext=0;
  1518.           xNext=0;
  1519.           rN=new int [8];
  1520.           rN[0]=seed[0]+1;
  1521.           rN[1]=seed[1]+1;
  1522.           rN[2]=seed[2]+1;
  1523.           rN[3]=seed[3]+1;
  1524.           rN[4]=seed[4]+1;
  1525.           rN[5]=seed[5]+1;
  1526.           rN[6]=seed[6]+1;
  1527.           rN[7]=seed[7]+1;
  1528.           yMod4=1;
  1529.           for (y=0; y <= maxY; ++y)
  1530.             {
  1531.               if (yMod4 == 1)
  1532.                 {
  1533.                   xMod8=1;
  1534.                   for (x=0; x <= maxX; ++x)
  1535.                     {
  1536.                       if ((((xMod8 == 0) && (y != 0) && (y != maxY))
  1537.                       ||  (xMod8 == 3) || (xMod8 == 4) || (xMod8 == 5)))
  1538.                         computerPage[y][x]='\000';
  1539.                       else
  1540.                         computerPage[y][x]='\002';
  1541.                       if (++xMod8 >= 8)
  1542.                         xMod8=0;
  1543.                     }
  1544.                 }
  1545.               else
  1546.                 if ((yMod4 == 0) || (yMod4 == 2))
  1547.                   {
  1548.                     xMod8=1;
  1549.                     for (x=0; x <= maxX; ++x)
  1550.                       {
  1551.                         if ((xMod8 == 2) || (xMod8 == 6))
  1552.                           computerPage[y][x]='\000';
  1553.                         else
  1554.                           computerPage[y][x]='\002';
  1555.                         if (++xMod8 >= 8)
  1556.                           xMod8=0;
  1557.                       }
  1558.                   }
  1559.                 else
  1560.                   {
  1561.                     xMod8=1;
  1562.                     for (x=0; x <= maxX; ++x)
  1563.                       {
  1564.                         if ((xMod8 == 0) || (xMod8 == 1) || (xMod8 == 4) 
  1565.                         ||  (xMod8 == 7))
  1566.                           computerPage[y][x]='\000';
  1567.                         else
  1568.                           computerPage[y][x]='\002';
  1569.                         if (++xMod8 >= 8)
  1570.                           xMod8=0;
  1571.                       }
  1572.                   }
  1573.               if (++yMod4 >= 4) 
  1574.                 yMod4=0;
  1575.             }
  1576.           columnNum=rN[0];
  1577.           rNIndex1=0;
  1578.           rNIndex2=1;
  1579.           while (rNIndex2 < 8)
  1580.             {
  1581.               temInt=rN[rNIndex2];
  1582.               rN[rNIndex1]=temInt;
  1583.               columnNum+=temInt;
  1584.               if (columnNum >= 727) 
  1585.                 columnNum-=727;
  1586.               rNIndex1=rNIndex2++;
  1587.             }
  1588.           rN[7]=columnNum;
  1589.           columnNum%=numColumns;
  1590.           x=4*columnNum+3;
  1591.           rowNum=rN[0];
  1592.           rNIndex1=0;
  1593.           rNIndex2=1;
  1594.           while (rNIndex2 < 8)
  1595.             {
  1596.               temInt=rN[rNIndex2];
  1597.               rN[rNIndex1]=temInt;
  1598.               rowNum+=temInt;
  1599.               if (rowNum >= 727) 
  1600.                 rowNum-=727;
  1601.               rNIndex1=rNIndex2++;
  1602.             }
  1603.           rN[7]=rowNum;
  1604.           if (columnNum%2 == 0)
  1605.             {
  1606.               rowNum%=numRows;
  1607.               y=4*rowNum+2;
  1608.             }
  1609.           else
  1610.             {
  1611.               rowNum%=(numRows-1);
  1612.               y=4*rowNum+4;
  1613.             }
  1614.           computerPage[y][x]='\002';
  1615.           stackHead=-1;
  1616.           do
  1617.             {
  1618.               deltaIndex1=0;
  1619.               do
  1620.                 {
  1621.                   deltaIndex2=rN[0];
  1622.                   rNIndex1=0;
  1623.                   rNIndex2=1;
  1624.                   while (rNIndex2 < 8)
  1625.                     {
  1626.                       temInt=rN[rNIndex2];
  1627.                       rN[rNIndex1]=temInt;
  1628.                       deltaIndex2+=temInt;
  1629.                       if (deltaIndex2 >= 727)
  1630.                         deltaIndex2-=727;
  1631.                       rNIndex1=rNIndex2++;
  1632.                     }
  1633.                   rN[7]=deltaIndex2;
  1634.                 }
  1635.               while (deltaIndex2 >= 720);
  1636.               passageFound=false;
  1637.               searchComplete=false;
  1638.               while (! searchComplete)
  1639.                 {
  1640.                   while ((deltaIndex1 < 6) && (! passageFound))
  1641.                     {
  1642.                       xNext=x+2*hexDeltaX[deltaIndex1][deltaIndex2];
  1643.                       if (xNext <= 0)
  1644.                         ++deltaIndex1;
  1645.                       else
  1646.                         if (xNext > maxX)
  1647.                           ++deltaIndex1;
  1648.                         else
  1649.                           {
  1650.                             yNext=y+2*hexDeltaY[deltaIndex1][deltaIndex2];
  1651.                             if (yNext <= 0)
  1652.                               ++deltaIndex1;
  1653.                             else
  1654.                               if (yNext > maxY)
  1655.                                 ++deltaIndex1;
  1656.                               else
  1657.                                 if (computerPage[yNext][xNext] == '\000')
  1658.                                   passageFound=true;
  1659.                                 else
  1660.                                   ++deltaIndex1;
  1661.                           }
  1662.                     }
  1663.                   if (! passageFound)
  1664.                     {
  1665.                       if (stackHead >= 0)
  1666.                         {
  1667.                           deltaIndex1=stack[stackHead].index1;
  1668.                           deltaIndex2=stack[stackHead--].index2;
  1669.                           x-=2*hexDeltaX[deltaIndex1][deltaIndex2];
  1670.                           y-=2*hexDeltaY[deltaIndex1++][deltaIndex2];
  1671.                         }
  1672.                     }
  1673.                   searchComplete
  1674.                    =(passageFound || ((stackHead == -1) && (deltaIndex1 >= 6)));
  1675.                 }
  1676.               if (passageFound)
  1677.                 {
  1678.                   stack[++stackHead].index1=(short) deltaIndex1;
  1679.                   stack[stackHead].index2=(short) deltaIndex2;
  1680.                   computerPage[yNext][xNext]='\002';
  1681.                   computerPage[(y+yNext)/2][(x+xNext)/2]='\002';
  1682.                   x=xNext;
  1683.                   y=yNext;
  1684.                 }
  1685.             }
  1686.           while (stackHead != -1);
  1687.           computerPage[0][3]='\001';
  1688.           computerPage[maxY][maxX-3]='\002';
  1689.           return;
  1690.         }
  1691.  
  1692.     private void hexSelectMaze()
  1693.         {
  1694.           int    adjacency;
  1695.           int    counter0;
  1696.           int    counter1;
  1697.           int    counter2;
  1698.           int    counter3;
  1699.           int    counter4;
  1700.           int    counter5;
  1701.           int    counter6;
  1702.           int    counter7;
  1703.           Date   today;
  1704.           double elapsedTime;
  1705.           int    minAdjacency;
  1706.           int    numRoomsInSolution;
  1707.           int    numRoomsInSolutionAtMin;
  1708.           int    seedByte [];
  1709.           int    seedByteAtMin [];
  1710.           double startTime;
  1711.         
  1712.           adjacency=0;
  1713.           numRoomsInSolution=0;
  1714.           seedByte=new int [8];
  1715.           seedByteAtMin=new int [8];
  1716.           counter0=seed[0];
  1717.           counter1=seed[1];
  1718.           counter2=seed[2];
  1719.           counter3=seed[3];
  1720.           counter4=seed[4];
  1721.           counter5=seed[5];
  1722.           counter6=seed[6];
  1723.           counter7=seed[7];
  1724.           hash();
  1725.           minAdjacency=4*numRoomsInMaze+1;
  1726.           numRoomsInSolutionAtMin=0;
  1727.           seedByteAtMin[0]=counter0;
  1728.           seedByteAtMin[1]=counter1;
  1729.           seedByteAtMin[2]=counter2;
  1730.           seedByteAtMin[3]=counter3;
  1731.           seedByteAtMin[4]=counter4;
  1732.           seedByteAtMin[5]=counter5;
  1733.           seedByteAtMin[6]=counter6;
  1734.           seedByteAtMin[7]=counter7;
  1735.           today=new Date();
  1736.           startTime=((double) today.getTime())/1000.0;
  1737.           do
  1738.             {
  1739.               seedByte[0]=counter0;
  1740.               seedByte[1]=counter1;
  1741.               seedByte[2]=counter2;
  1742.               seedByte[3]=counter3;
  1743.               seedByte[4]=counter4;
  1744.               seedByte[5]=counter5;
  1745.               seedByte[6]=counter6;
  1746.               seedByte[7]=counter7;
  1747.               hexGenerateMaze(seedByte);
  1748.               hexSolveMaze();
  1749.               if (3*numRoomsInSolution >= numRoomsInMaze)
  1750.                 {
  1751.                   if (adjacency < minAdjacency)
  1752.                     {
  1753.                       minAdjacency=adjacency;
  1754.                       numRoomsInSolutionAtMin=numRoomsInSolution;
  1755.                       seedByteAtMin[0]=seedByte[0];
  1756.                       seedByteAtMin[1]=seedByte[1];
  1757.                       seedByteAtMin[2]=seedByte[2];
  1758.                       seedByteAtMin[3]=seedByte[3];
  1759.                       seedByteAtMin[4]=seedByte[4];
  1760.                       seedByteAtMin[5]=seedByte[5];
  1761.                       seedByteAtMin[6]=seedByte[6];
  1762.                       seedByteAtMin[7]=seedByte[7];
  1763.                     }
  1764.                   else
  1765.                     {
  1766.                       if (adjacency == minAdjacency)
  1767.                         {
  1768.                           if (numRoomsInSolution > numRoomsInSolutionAtMin)
  1769.                             {
  1770.                               numRoomsInSolutionAtMin=numRoomsInSolution;
  1771.                               seedByteAtMin[0]=seedByte[0];
  1772.                               seedByteAtMin[1]=seedByte[1];
  1773.                               seedByteAtMin[2]=seedByte[2];
  1774.                               seedByteAtMin[3]=seedByte[3];
  1775.                               seedByteAtMin[4]=seedByte[4];
  1776.                               seedByteAtMin[5]=seedByte[5];
  1777.                               seedByteAtMin[6]=seedByte[6];
  1778.                               seedByteAtMin[7]=seedByte[7];
  1779.                             }
  1780.                         }
  1781.                     }
  1782.                 }
  1783.               increment();
  1784.               today=new Date();
  1785.               elapsedTime=((double) today.getTime())/1000.0-startTime;
  1786.             }
  1787.           while ((elapsedTime >= 0.0) 
  1788.           &&     (elapsedTime < SECONDS_FOR_MAZE_SELECTION));
  1789.           hexGenerateMaze(seedByteAtMin);
  1790.           hexSolveMaze();
  1791.           return;
  1792.         }
  1793.  
  1794.     public void hexDisplaySolution()
  1795.         {
  1796.           int     deltaIndex;
  1797.           boolean pathFound;
  1798.           int     x;
  1799.           int     xNext;
  1800.           int     xPrevious;
  1801.           double  xRelative;
  1802.           double  xRelativeNext;
  1803.           int     y;
  1804.           int     yNext;
  1805.           int     yPrevious;
  1806.           double  yRelative;
  1807.           double  yRelativeNext;
  1808.  
  1809.           xRelative=1.0;
  1810.           yRelative=sqrt3/2.0;
  1811.           xRelativeNext=0.0;
  1812.           yRelativeNext=0.0;
  1813.           graph.setColor(redGreenBlue[SOLUTION_COLOR]);
  1814.           drawLine(1.0,0.0,xRelative,yRelative);
  1815.           xPrevious=3;
  1816.           yPrevious=-2;
  1817.           x=3;
  1818.           y=2;
  1819.           xNext=0;
  1820.           yNext=0;
  1821.           do
  1822.             {
  1823.               pathFound=false;
  1824.               deltaIndex=0;
  1825.               while (! pathFound)
  1826.                 {
  1827.                   xNext=x+hexDeltaX[deltaIndex][0];
  1828.                   yNext=y+hexDeltaY[deltaIndex][0];
  1829.                   if (computerPage[yNext][xNext] == '\001')
  1830.                     {
  1831.                       xNext+=hexDeltaX[deltaIndex][0];
  1832.                       yNext+=hexDeltaY[deltaIndex][0];
  1833.                       if ((xNext != xPrevious) || (yNext != yPrevious))
  1834.                         pathFound=true;
  1835.                       else
  1836.                         ++deltaIndex;
  1837.                     }
  1838.                   else
  1839.                     ++deltaIndex;
  1840.                 }
  1841.               if (yNext < maxY)
  1842.                 {
  1843.                   switch (yNext-y)
  1844.                     {
  1845.                       case -4:
  1846.                         xRelativeNext=xRelative;
  1847.                         yRelativeNext=yRelative-sqrt3;
  1848.                         break;
  1849.                       case -2:
  1850.                         if (xNext > x)
  1851.                           {
  1852.                             xRelativeNext=xRelative+3.0/2.0;
  1853.                             yRelativeNext=yRelative-sqrt3/2.0;
  1854.                           }
  1855.                         else
  1856.                           {
  1857.                             xRelativeNext=xRelative-3.0/2.0;
  1858.                             yRelativeNext=yRelative-sqrt3/2.0;
  1859.                           }
  1860.                         break;
  1861.                       case 2:
  1862.                         if (xNext > x)
  1863.                           {
  1864.                             xRelativeNext=xRelative+3.0/2.0;
  1865.                             yRelativeNext=yRelative+sqrt3/2.0;
  1866.                           }
  1867.                         else
  1868.                           {
  1869.                             xRelativeNext=xRelative-3.0/2.0;
  1870.                             yRelativeNext=yRelative+sqrt3/2.0;
  1871.                           }
  1872.                         break;
  1873.                       default:
  1874.                         xRelativeNext=xRelative;
  1875.                         yRelativeNext=yRelative+sqrt3;
  1876.                         break;
  1877.                     }
  1878.                   drawLine(xRelative,yRelative,xRelativeNext,yRelativeNext);
  1879.                 }
  1880.               else
  1881.                 drawLine(xRelative,yRelative,xRelative,yMax);
  1882.               xPrevious=x;
  1883.               yPrevious=y;
  1884.               x=xNext;
  1885.               y=yNext;
  1886.               xRelative=xRelativeNext;
  1887.               yRelative=yRelativeNext;
  1888.             }
  1889.           while (yNext < maxY);
  1890.           return;
  1891.         }
  1892.  
  1893.     private void hexOutputMaze()
  1894.       {
  1895.         int       cornerX [];
  1896.         int       cornerY [];
  1897.         int       digitNum;
  1898.         long      dividend;
  1899.         int       objectNum;
  1900.         long      quotient;
  1901.         double    radians;
  1902.         double    radiansPerDegree;
  1903.         int       roomNum;
  1904.         VertexRec singleRectangle [];
  1905.         VertexRec singleTriangle [];
  1906.         double    temDouble1;
  1907.         double    temDouble2;
  1908.         double    temDouble3;
  1909.         double    temDouble4;
  1910.         Date      today;
  1911.         VertexRec triangle [] [];
  1912.         int       vertexNum;
  1913.         int       xMod8;
  1914.         double    x0;
  1915.         double    x1;
  1916.         double    x2;
  1917.         double    x3;
  1918.         double    y0;
  1919.         double    y1;
  1920.         double    y2;
  1921.         double    y3;
  1922.     
  1923.         singleRectangle=new VertexRec [4];
  1924.         for (vertexNum=0; vertexNum < 4; ++vertexNum)
  1925.           singleRectangle[vertexNum]=new VertexRec();
  1926.         singleTriangle=new VertexRec [3];
  1927.         for (vertexNum=0; vertexNum < 3; ++vertexNum)
  1928.           singleTriangle[vertexNum]=new VertexRec();
  1929.         triangle=new VertexRec [4] [3];
  1930.         for (objectNum=0; objectNum < 4; ++objectNum)
  1931.           for (vertexNum=0; vertexNum < 3; ++vertexNum)
  1932.             triangle[objectNum][vertexNum]=new VertexRec();
  1933.         switch (state)
  1934.           {
  1935.             case 0:
  1936.               if (resize)
  1937.                 {
  1938.                   seed=new int [8];
  1939.                   today=new Date();
  1940.                   dividend=today.getTime();
  1941.                   for (digitNum=0; digitNum < 8; ++digitNum)
  1942.                     {
  1943.                       quotient=dividend/10;
  1944.                       seed[digitNum]=(int) (dividend-10*quotient);
  1945.                       dividend=quotient;
  1946.                     }
  1947.                   temDouble1=((double) (screen.width))*0.28;
  1948.                   temDouble2=(double) MIN_WALL_LENGTH_IN_INCHES;
  1949.                   temDouble2*=25.4;
  1950.                   temDouble3=(double) RELATIVE_WIDTH_OF_WALL;
  1951.                   numColumns=(int) (2.0*(temDouble1/temDouble2-2.0
  1952.                    -temDouble3/sqrt3)/3.0+1.0);
  1953.                   if ((numColumns%2) == 0)
  1954.                     --numColumns;
  1955.                   if (numColumns < 3)
  1956.                     numColumns=3;
  1957.                   temDouble1=((double) (screen.height))*0.28;
  1958.                   temDouble2=((double) (screen.width))*0.28;
  1959.                   temDouble3=(double) numColumns;
  1960.                   temDouble4=(double) RELATIVE_WIDTH_OF_WALL;
  1961.                   numRows=(int) (((temDouble1/temDouble2)
  1962.                    *(3.0*(temDouble3-1.0)/2.0+2.0+temDouble4/sqrt3)-temDouble4)
  1963.                    /sqrt3);
  1964.                   if (numRows < 2) 
  1965.                     numRows=2;
  1966.                   maxX=8*(numColumns/2)+6;
  1967.                   maxY=4*numRows;
  1968.                   numRoomsInMaze=numRows*numColumns-(numColumns/2);
  1969.                   computerPage=new char [maxY+1] [maxX+1];
  1970.                   userPage=new char [maxY+1] [maxX+1];
  1971.                   clearUserAttempts=true;
  1972.                   stack=new StackRec [numRoomsInMaze];
  1973.                   for (roomNum=0; roomNum < numRoomsInMaze; ++roomNum)
  1974.                     stack[roomNum]=new StackRec();
  1975.                   hexSelectMaze();
  1976.                   resize=false;
  1977.                 }
  1978.               if (clearUserAttempts)
  1979.                 {
  1980.                   for (userX=0; userX <= maxX; ++userX)
  1981.                     for (userY=0; userY <= maxY; ++userY)
  1982.                       if (computerPage[userY][userX] == '\000')
  1983.                         userPage[userY][userX]='\000';
  1984.                       else
  1985.                         userPage[userY][userX]='\002';
  1986.                   userX=3;
  1987.                   userXRelative=1.0;
  1988.                   userY=2;
  1989.                   userYRelative=sqrt3/2.0;
  1990.                   userPage[userY][userX]='\001';
  1991.                   clearUserAttempts=false;
  1992.                 }
  1993.               if (paint)
  1994.                 {
  1995.                   cornerX=new int [4];
  1996.                   cornerY=new int [4];
  1997.                   cornerX[0]=0;
  1998.                   cornerY[0]=0;
  1999.                   cornerX[1]=0;
  2000.                   cornerY[1]=screen.height;
  2001.                   cornerX[2]=screen.width;
  2002.                   cornerY[2]=screen.height;
  2003.                   cornerX[3]=screen.width;
  2004.                   cornerY[3]=0;
  2005.                   graph.setColor(new Color(255,255,255));
  2006.                   graph.fillPolygon(cornerX,cornerY,4);
  2007.                   radiansPerDegree=Math.atan(1.0)/45.0;
  2008.                   radians=tilt*radiansPerDegree;
  2009.                   sinTilt=Math.sin(radians);
  2010.                   cosTilt=Math.cos(radians);
  2011.                   temDouble1=(double) numColumns;
  2012.                   xMax=3.0*(temDouble1-1.0)/2.0+2.0+RELATIVE_WIDTH_OF_WALL/sqrt3;
  2013.                   temDouble1=(double) (screen.width);
  2014.                   pixelsPerX=(temDouble1-1.0)
  2015.                    /(xMax*(xMax/(xMax-RELATIVE_HEIGHT_OF_WALL)));
  2016.                   xOffset=(xMax/2.0)
  2017.                    *(RELATIVE_HEIGHT_OF_WALL/(xMax-RELATIVE_HEIGHT_OF_WALL));
  2018.                   temDouble1=(double) numRows;
  2019.                   yMax=temDouble1*sqrt3+RELATIVE_WIDTH_OF_WALL;
  2020.                   temDouble1=(double) (screen.height);
  2021.                   pixelsPerZ=(temDouble1-1.0)/Math.sqrt(yMax*yMax
  2022.                    +RELATIVE_HEIGHT_OF_WALL*RELATIVE_HEIGHT_OF_WALL);
  2023.                   if (yMax > xMax)
  2024.                     relDistOfUserFromScreen=yMax;
  2025.                   else
  2026.                     relDistOfUserFromScreen=xMax;
  2027.                   paint=false;
  2028.                 }
  2029.               if (state == 0)
  2030.                 state=1;
  2031.               break;
  2032.             case 1:
  2033.               baseTriangle[0][0].x=0.0;
  2034.               baseTriangle[0][0].y=RELATIVE_WIDTH_OF_WALL+sqrt3/2.0;
  2035.               baseTriangle[0][1].x=0.0;
  2036.               baseTriangle[0][1].y=sqrt3/2.0;
  2037.               baseTriangle[0][2].x=RELATIVE_WIDTH_OF_WALL*sqrt3/2.0;
  2038.               baseTriangle[0][2].y=(RELATIVE_WIDTH_OF_WALL+sqrt3)/2.0;
  2039.               baseTriangle[1][0].x=(1.0-RELATIVE_WIDTH_OF_WALL/sqrt3)/2.0;
  2040.               baseTriangle[1][0].y=RELATIVE_WIDTH_OF_WALL/2.0;
  2041.               baseTriangle[1][1].x=0.5+RELATIVE_WIDTH_OF_WALL/sqrt3;
  2042.               baseTriangle[1][1].y=0.0;
  2043.               baseTriangle[1][2].x=baseTriangle[1][1].x;
  2044.               baseTriangle[1][2].y=RELATIVE_WIDTH_OF_WALL;
  2045.               baseTriangle[2][0].x=1.5;
  2046.               baseTriangle[2][0].y=RELATIVE_WIDTH_OF_WALL;
  2047.               baseTriangle[2][1].x=1.5;
  2048.               baseTriangle[2][1].y=0.0;
  2049.               baseTriangle[2][2].x=1.5*(1.0+RELATIVE_WIDTH_OF_WALL/sqrt3);
  2050.               baseTriangle[2][2].y=RELATIVE_WIDTH_OF_WALL/2.0;
  2051.               baseTriangle[3][0].x=2.0-RELATIVE_WIDTH_OF_WALL/(2.0*sqrt3);
  2052.               baseTriangle[3][0].y=baseTriangle[0][2].y;
  2053.               baseTriangle[3][1].x=2.0+RELATIVE_WIDTH_OF_WALL/sqrt3;
  2054.               baseTriangle[3][1].y=baseTriangle[0][1].y;
  2055.               baseTriangle[3][2].x=baseTriangle[3][1].x;
  2056.               baseTriangle[3][2].y=baseTriangle[0][0].y;
  2057.               baseRectangle[0][0].x=baseTriangle[0][2].x;
  2058.               baseRectangle[0][0].y=baseTriangle[0][2].y;
  2059.               baseRectangle[0][1].x=baseTriangle[1][1].x;
  2060.               baseRectangle[0][1].y=sqrt3;
  2061.               baseRectangle[0][2].x=baseTriangle[1][0].x;
  2062.               baseRectangle[0][2].y=sqrt3+RELATIVE_WIDTH_OF_WALL/2.0;
  2063.               baseRectangle[0][3].x=baseTriangle[0][0].x;
  2064.               baseRectangle[0][3].y=baseTriangle[0][0].y;
  2065.               baseRectangle[1][0].x=baseTriangle[0][1].x;
  2066.               baseRectangle[1][0].y=baseTriangle[0][1].y;
  2067.               baseRectangle[1][1].x=baseTriangle[1][0].x;
  2068.               baseRectangle[1][1].y=baseTriangle[1][0].y;
  2069.               baseRectangle[1][2].x=baseTriangle[1][2].x;
  2070.               baseRectangle[1][2].y=baseTriangle[1][2].y;
  2071.               baseRectangle[1][3].x=baseTriangle[0][2].x;
  2072.               baseRectangle[1][3].y=baseTriangle[0][2].y;
  2073.               baseRectangle[2][0].x=baseTriangle[1][1].x;
  2074.               baseRectangle[2][0].y=baseTriangle[1][1].y;
  2075.               baseRectangle[2][1].x=baseTriangle[2][1].x;
  2076.               baseRectangle[2][1].y=baseTriangle[2][1].y;
  2077.               baseRectangle[2][2].x=baseTriangle[2][0].x;
  2078.               baseRectangle[2][2].y=baseTriangle[2][0].y;
  2079.               baseRectangle[2][3].x=baseTriangle[1][2].x;
  2080.               baseRectangle[2][3].y=baseTriangle[1][2].y;
  2081.               baseRectangle[3][0].x=baseTriangle[2][2].x;
  2082.               baseRectangle[3][0].y=baseTriangle[2][2].y;
  2083.               baseRectangle[3][1].x=baseTriangle[3][1].x;
  2084.               baseRectangle[3][1].y=baseTriangle[3][1].y;
  2085.               baseRectangle[3][2].x=baseTriangle[3][0].x;
  2086.               baseRectangle[3][2].y=baseTriangle[3][0].y;
  2087.               baseRectangle[3][3].x=baseTriangle[2][0].x;
  2088.               baseRectangle[3][3].y=baseTriangle[2][0].y;
  2089.               baseRectangle[4][0].x=baseTriangle[3][1].x;
  2090.               baseRectangle[4][0].y=baseTriangle[3][1].y;
  2091.               baseRectangle[4][1].x=baseTriangle[3][1].x
  2092.                +(baseTriangle[2][1].x-baseTriangle[1][1].x);
  2093.               baseRectangle[4][1].y=baseTriangle[3][1].y;
  2094.               baseRectangle[4][2].x=baseRectangle[4][1].x;
  2095.               baseRectangle[4][2].y=baseTriangle[3][2].y;
  2096.               baseRectangle[4][3].x=baseTriangle[3][2].x;
  2097.               baseRectangle[4][3].y=baseTriangle[3][2].y;
  2098.               baseRectangle[5][0].x=baseRectangle[0][1].x
  2099.                +(baseTriangle[2][1].x-baseTriangle[1][1].x);
  2100.               baseRectangle[5][0].y=baseRectangle[0][1].y;
  2101.               baseRectangle[5][1].x=baseTriangle[3][0].x;
  2102.               baseRectangle[5][1].y=baseTriangle[3][0].y;
  2103.               baseRectangle[5][2].x=baseTriangle[3][2].x;
  2104.               baseRectangle[5][2].y=baseTriangle[3][2].y;
  2105.               baseRectangle[5][3].x=baseRectangle[0][2].x
  2106.                +(baseTriangle[2][2].x-baseTriangle[1][0].x);
  2107.               baseRectangle[5][3].y=baseRectangle[0][2].y;
  2108.               rectangle[0][0].x=baseTriangle[1][1].x;
  2109.               rectangle[0][0].y=baseTriangle[1][1].y;
  2110.               rectangle[0][1].x=xMax-baseTriangle[1][1].x;
  2111.               rectangle[0][1].y=baseTriangle[1][1].y;
  2112.               rectangle[0][2].x=xMax-baseTriangle[1][2].x;
  2113.               rectangle[0][2].y=baseTriangle[1][2].y;
  2114.               rectangle[0][3].x=baseTriangle[1][2].x;
  2115.               rectangle[0][3].y=baseTriangle[1][2].y;
  2116.               rectangle[1][0].x=baseTriangle[0][1].x;
  2117.               rectangle[1][0].y=baseTriangle[0][1].y;
  2118.               rectangle[1][1].x=xMax-baseTriangle[0][1].x;
  2119.               rectangle[1][1].y=baseTriangle[0][1].y;
  2120.               rectangle[1][2].x=xMax-baseTriangle[1][2].x;
  2121.               rectangle[1][2].y=baseTriangle[1][2].y;
  2122.               rectangle[1][3].x=baseTriangle[1][2].x;
  2123.               rectangle[1][3].y=baseTriangle[1][2].y;
  2124.               rectangle[2][0].x=baseTriangle[0][1].x;
  2125.               rectangle[2][0].y=baseTriangle[0][1].y;
  2126.               rectangle[2][1].x=xMax-baseTriangle[0][1].x;
  2127.               rectangle[2][1].y=baseTriangle[0][1].y;
  2128.               rectangle[2][2].x=xMax-baseTriangle[0][0].x;
  2129.               rectangle[2][2].y=baseTriangle[0][0].y;
  2130.               rectangle[2][3].x=baseTriangle[0][0].x;
  2131.               rectangle[2][3].y=baseTriangle[0][0].y;
  2132.               rectangle[3][0].x=baseTriangle[0][0].x;
  2133.               rectangle[3][0].y=baseTriangle[0][0].y;
  2134.               rectangle[3][1].x=xMax-baseTriangle[0][0].x;
  2135.               rectangle[3][1].y=baseTriangle[0][0].y;
  2136.               rectangle[3][2].x=xMax-baseRectangle[0][1].x;
  2137.               rectangle[3][2].y=baseRectangle[0][1].y;
  2138.               rectangle[3][3].x=baseRectangle[0][1].x;
  2139.               rectangle[3][3].y=baseRectangle[0][1].y;
  2140.               y=0;
  2141.               state=2;
  2142.               break;
  2143.             case 2:
  2144.               if (y <= maxY-1) 
  2145.                 {
  2146.                   if (y > 0)
  2147.                     {
  2148.                       x0=rectangle[0][0].x;
  2149.                       y0=rectangle[0][0].y;
  2150.                       x1=rectangle[0][1].x;
  2151.                       y1=rectangle[0][1].y;
  2152.                       x2=rectangle[0][2].x;
  2153.                       y2=rectangle[0][2].y;
  2154.                       x3=rectangle[0][3].x;
  2155.                       y3=rectangle[0][3].y;
  2156.                       displayQuadrilateral(x0,y0,0.0,x1,y1,
  2157.                        0.0,x2,y2,0.0,x3,y3,0.0,FLOOR_COLOR);
  2158.                       x0=rectangle[1][0].x;
  2159.                       y0=rectangle[1][0].y;
  2160.                       x1=rectangle[1][1].x;
  2161.                       y1=rectangle[1][1].y;
  2162.                       x2=rectangle[1][2].x;
  2163.                       y2=rectangle[1][2].y;
  2164.                       x3=rectangle[1][3].x;
  2165.                       y3=rectangle[1][3].y;
  2166.                       displayQuadrilateral(x0,y0,0.0,x1,y1,
  2167.                        0.0,x2,y2,0.0,x3,y3,0.0,FLOOR_COLOR);
  2168.                     }
  2169.                   x0=rectangle[2][0].x;
  2170.                   y0=rectangle[2][0].y;
  2171.                   x1=rectangle[2][1].x;
  2172.                   y1=rectangle[2][1].y;
  2173.                   x2=rectangle[2][2].x;
  2174.                   y2=rectangle[2][2].y;
  2175.                   x3=rectangle[2][3].x;
  2176.                   y3=rectangle[2][3].y;
  2177.                   displayQuadrilateral(x0,y0,0.0,x1,y1,0.0,x2,
  2178.                    y2,0.0,x3,y3,0.0,FLOOR_COLOR);
  2179.                   if (y < maxY-4)
  2180.                     {
  2181.                       x0=rectangle[3][0].x;
  2182.                       y0=rectangle[3][0].y;
  2183.                       x1=rectangle[3][1].x;
  2184.                       y1=rectangle[3][1].y;
  2185.                       x2=rectangle[3][2].x;
  2186.                       y2=rectangle[3][2].y;
  2187.                       x3=rectangle[3][3].x;
  2188.                       y3=rectangle[3][3].y;
  2189.                       displayQuadrilateral(x0,y0,0.0,x1,y1,
  2190.                        0.0,x2,y2,0.0,x3,y3,0.0,FLOOR_COLOR);
  2191.                     }
  2192.                   for (objectNum=0; objectNum < 4; ++objectNum)
  2193.                     for (vertexNum=0; vertexNum < 4; ++vertexNum)
  2194.                       rectangle[objectNum][vertexNum].y+=sqrt3;
  2195.                   y+=4;
  2196.                 }
  2197.               else
  2198.                 {
  2199.                   rectangle[0][0].x=baseTriangle[1][0].x;
  2200.                   rectangle[0][0].y=baseTriangle[1][0].y;
  2201.                   rectangle[0][1].x=baseTriangle[1][1].x;
  2202.                   rectangle[0][1].y=baseTriangle[1][1].y;
  2203.                   rectangle[0][2].x=baseTriangle[2][1].x;
  2204.                   rectangle[0][2].y=baseTriangle[2][1].y;
  2205.                   rectangle[0][3].x=baseTriangle[2][2].x;
  2206.                   rectangle[0][3].y=baseTriangle[2][2].y;
  2207.                   rectangle[1][0].x=baseTriangle[0][1].x;
  2208.                   rectangle[1][0].y=baseTriangle[0][1].y;
  2209.                   rectangle[1][1].x=baseTriangle[1][0].x;
  2210.                   rectangle[1][1].y=baseTriangle[1][0].y;
  2211.                   rectangle[1][2].x=baseTriangle[2][2].x;
  2212.                   rectangle[1][2].y=baseTriangle[2][2].y;
  2213.                   rectangle[1][3].x=baseTriangle[3][1].x;
  2214.                   rectangle[1][3].y=baseTriangle[3][1].y;
  2215.                   rectangle[2][0].x=baseTriangle[0][0].x;
  2216.                   rectangle[2][0].y=baseTriangle[0][0].y;
  2217.                   rectangle[2][1].x=baseTriangle[0][1].x;
  2218.                   rectangle[2][1].y=baseTriangle[0][1].y;
  2219.                   rectangle[2][2].x=baseTriangle[3][1].x;
  2220.                   rectangle[2][2].y=baseTriangle[3][1].y;
  2221.                   rectangle[2][3].x=baseTriangle[3][2].x;
  2222.                   rectangle[2][3].y=baseTriangle[3][2].y;
  2223.                   x=0;
  2224.                   state=3;
  2225.                 }
  2226.               break;
  2227.             case 3:
  2228.               if (x <= maxX)
  2229.                 {
  2230.                   for (objectNum=0; objectNum < 3; ++objectNum)
  2231.                     {
  2232.                       x0=rectangle[objectNum][0].x;
  2233.                       y0=rectangle[objectNum][0].y;
  2234.                       x1=rectangle[objectNum][1].x;
  2235.                       y1=rectangle[objectNum][1].y;
  2236.                       x2=rectangle[objectNum][2].x;
  2237.                       y2=rectangle[objectNum][2].y;
  2238.                       x3=rectangle[objectNum][3].x;
  2239.                       y3=rectangle[objectNum][3].y;
  2240.                       displayQuadrilateral(x0,y0,0.0,x1,y1,
  2241.                        0.0,x2,y2,0.0,x3,y3,0.0,FLOOR_COLOR);
  2242.                       x0=rectangle[objectNum][0].x;
  2243.                       y0=yMax-rectangle[objectNum][0].y;
  2244.                       x1=rectangle[objectNum][1].x;
  2245.                       y1=yMax-rectangle[objectNum][1].y;
  2246.                       x2=rectangle[objectNum][2].x;
  2247.                       y2=yMax-rectangle[objectNum][2].y;
  2248.                       x3=rectangle[objectNum][3].x;
  2249.                       y3=yMax-rectangle[objectNum][3].y;
  2250.                       displayQuadrilateral(x0,y0,0.0,x1,y1,
  2251.                        0.0,x2,y2,0.0,x3,y3,0.0,FLOOR_COLOR);
  2252.                       for (vertexNum=0; vertexNum < 4; ++vertexNum)
  2253.                         rectangle[objectNum][vertexNum].x+=3.0;
  2254.                     }
  2255.                   x+=8;
  2256.                 }
  2257.               else
  2258.                 {
  2259.                   yMod4=0;
  2260.                   yOffset=0.0;
  2261.                   y=0;
  2262.                   state=4;
  2263.                 }
  2264.               break;
  2265.             case 4:
  2266.               if (y <= maxY)
  2267.                 {
  2268.                   switch (yMod4)
  2269.                     {
  2270.                       case 0:
  2271.                         xMod8=0;
  2272.                         for (objectNum=1; objectNum <= 2; ++objectNum)
  2273.                           for (vertexNum=0; vertexNum < 3; ++vertexNum)
  2274.                             {
  2275.                               triangle[objectNum][vertexNum].x
  2276.                                =baseTriangle[objectNum][vertexNum].x;
  2277.                               triangle[objectNum][vertexNum].y
  2278.                                =baseTriangle[objectNum][vertexNum].y+yOffset;
  2279.                             }
  2280.                         for (vertexNum=0; vertexNum < 4; ++vertexNum)
  2281.                           {
  2282.                             rectangle[2][vertexNum].x
  2283.                              =baseRectangle[2][vertexNum].x;
  2284.                             rectangle[2][vertexNum].y
  2285.                              =baseRectangle[2][vertexNum].y+yOffset;
  2286.                           }
  2287.                         for (x=0; x <= maxX; ++x)
  2288.                           {
  2289.                             switch (xMod8)
  2290.                               {
  2291.                                 case 2:
  2292.                                   singleTriangle[0].x=triangle[1][0].x;
  2293.                                   singleTriangle[0].y=triangle[1][0].y;
  2294.                                   singleTriangle[1].x=triangle[1][1].x;
  2295.                                   singleTriangle[1].y=triangle[1][1].y;
  2296.                                   singleTriangle[2].x=triangle[1][2].x;
  2297.                                   singleTriangle[2].y=triangle[1][2].y;
  2298.                                   outputTriangle(singleTriangle,true,
  2299.                                    TRIANGLE_SSW_NNE_COLOR);
  2300.                                   break;
  2301.                                 case 4:
  2302.                                   singleTriangle[0].x=triangle[2][0].x;
  2303.                                   singleTriangle[0].y=triangle[2][0].y;
  2304.                                   singleTriangle[1].x=triangle[2][1].x;
  2305.                                   singleTriangle[1].y=triangle[2][1].y;
  2306.                                   singleTriangle[2].x=triangle[2][2].x;
  2307.                                   singleTriangle[2].y=triangle[2][2].y;
  2308.                                   outputTriangle(singleTriangle,true,
  2309.                                    TRIANGLE_SSE_NNW_COLOR);
  2310.                                   break;
  2311.                                 default:
  2312.                                   break;
  2313.                               }
  2314.                             if (++xMod8 >= 8)
  2315.                               {
  2316.                                 xMod8=0;
  2317.                                 for (objectNum=1; objectNum <= 2; ++objectNum)
  2318.                                   for (vertexNum=0; vertexNum < 3; ++vertexNum)
  2319.                                     triangle[objectNum][vertexNum].x+=3.0;
  2320.                                 for (vertexNum=0; vertexNum < 4; ++vertexNum)
  2321.                                   rectangle[2][vertexNum].x+=3.0;
  2322.                               }
  2323.                           }
  2324.                         xMod8=0;
  2325.                         for (objectNum=1; objectNum <= 2; ++objectNum)
  2326.                           for (vertexNum=0; vertexNum < 3; ++vertexNum)
  2327.                             {
  2328.                               triangle[objectNum][vertexNum].x
  2329.                                =baseTriangle[objectNum][vertexNum].x;
  2330.                               triangle[objectNum][vertexNum].y
  2331.                                =baseTriangle[objectNum][vertexNum].y+yOffset;
  2332.                             }
  2333.                         for (vertexNum=0; vertexNum < 4; ++vertexNum)
  2334.                           {
  2335.                             rectangle[2][vertexNum].x
  2336.                              =baseRectangle[2][vertexNum].x;
  2337.                             rectangle[2][vertexNum].y
  2338.                              =baseRectangle[2][vertexNum].y+yOffset;
  2339.                           }
  2340.                         for (x=0; x <= maxX; ++x)
  2341.                           {
  2342.                             switch (xMod8)
  2343.                               {
  2344.                                 case 2:
  2345.                                   singleTriangle[0].x=triangle[1][0].x;
  2346.                                   singleTriangle[0].y=triangle[1][0].y;
  2347.                                   singleTriangle[1].x=triangle[1][1].x;
  2348.                                   singleTriangle[1].y=triangle[1][1].y;
  2349.                                   singleTriangle[2].x=triangle[1][2].x;
  2350.                                   singleTriangle[2].y=triangle[1][2].y;
  2351.                                   outputTriangle(singleTriangle,false,
  2352.                                    TRIANGLE_SE_NW_COLOR);
  2353.                                   break;
  2354.                                 case 3:
  2355.                                   if (computerPage[y][x] == '\000')
  2356.                                     {
  2357.                                       singleRectangle[0].x=rectangle[2][0].x;
  2358.                                       singleRectangle[0].y=rectangle[2][0].y;
  2359.                                       singleRectangle[1].x=rectangle[2][1].x;
  2360.                                       singleRectangle[1].y=rectangle[2][1].y;
  2361.                                       singleRectangle[2].x=rectangle[2][2].x;
  2362.                                       singleRectangle[2].y=rectangle[2][2].y;
  2363.                                       singleRectangle[3].x=rectangle[2][3].x;
  2364.                                       singleRectangle[3].y=rectangle[2][3].y;
  2365.                                       outputRectangle(singleRectangle,
  2366.                                        RECTANGLE_W_E_COLOR);
  2367.                                     }
  2368.                                   break;
  2369.                                 case 4:
  2370.                                   singleTriangle[0].x=triangle[2][0].x;
  2371.                                   singleTriangle[0].y=triangle[2][0].y;
  2372.                                   singleTriangle[1].x=triangle[2][1].x;
  2373.                                   singleTriangle[1].y=triangle[2][1].y;
  2374.                                   singleTriangle[2].x=triangle[2][2].x;
  2375.                                   singleTriangle[2].y=triangle[2][2].y;
  2376.                                   outputTriangle(singleTriangle,false,
  2377.                                    TRIANGLE_SW_NE_COLOR);
  2378.                                   break;
  2379.                                 default:
  2380.                                   break;
  2381.                               }
  2382.                             if (++xMod8 >= 8)
  2383.                               {
  2384.                                 xMod8=0;
  2385.                                 for (objectNum=1; objectNum <= 2; ++objectNum)
  2386.                                   for (vertexNum=0; vertexNum < 3; ++vertexNum)
  2387.                                     triangle[objectNum][vertexNum].x+=3.0;
  2388.                                 for (vertexNum=0; vertexNum < 4; ++vertexNum)
  2389.                                   rectangle[2][vertexNum].x+=3.0;
  2390.                               }
  2391.                           }
  2392.                         break;
  2393.                       case 1:
  2394.                         xMod8=0;
  2395.                         for (objectNum=1; objectNum < 4; objectNum+=2)
  2396.                           for (vertexNum=0; vertexNum < 4; ++vertexNum)
  2397.                             {
  2398.                               rectangle[objectNum][vertexNum].x
  2399.                                =baseRectangle[objectNum][vertexNum].x;
  2400.                               rectangle[objectNum][vertexNum].y
  2401.                                =baseRectangle[objectNum][vertexNum].y+yOffset;
  2402.                             }
  2403.                         for (x=0; x <= maxX; ++x)
  2404.                           {
  2405.                             switch (xMod8)
  2406.                               {
  2407.                                 case 1:
  2408.                                   if (computerPage[y][x] == '\000')
  2409.                                     {
  2410.                                       singleRectangle[0].x=rectangle[1][0].x;
  2411.                                       singleRectangle[0].y=rectangle[1][0].y;
  2412.                                       singleRectangle[1].x=rectangle[1][1].x;
  2413.                                       singleRectangle[1].y=rectangle[1][1].y;
  2414.                                       singleRectangle[2].x=rectangle[1][2].x;
  2415.                                       singleRectangle[2].y=rectangle[1][2].y;
  2416.                                       singleRectangle[3].x=rectangle[1][3].x;
  2417.                                       singleRectangle[3].y=rectangle[1][3].y;
  2418.                                       outputRectangle(singleRectangle,
  2419.                                        RECTANGLE_SW_NE_COLOR);
  2420.                                     }
  2421.                                   break;
  2422.                                 case 5:
  2423.                                   if (computerPage[y][x] == '\000')
  2424.                                     {
  2425.                                       singleRectangle[0].x=rectangle[3][0].x;
  2426.                                       singleRectangle[0].y=rectangle[3][0].y;
  2427.                                       singleRectangle[1].x=rectangle[3][1].x;
  2428.                                       singleRectangle[1].y=rectangle[3][1].y;
  2429.                                       singleRectangle[2].x=rectangle[3][2].x;
  2430.                                       singleRectangle[2].y=rectangle[3][2].y;
  2431.                                       singleRectangle[3].x=rectangle[3][3].x;
  2432.                                       singleRectangle[3].y=rectangle[3][3].y;
  2433.                                       outputRectangle(singleRectangle,
  2434.                                        RECTANGLE_SE_NW_COLOR);
  2435.                                     }
  2436.                                   break;
  2437.                                 default:
  2438.                                   break;
  2439.                               }
  2440.                             if (++xMod8 >= 8)
  2441.                               {
  2442.                                 xMod8=0;
  2443.                                 for (objectNum=1; objectNum < 4; objectNum+=2)
  2444.                                   for (vertexNum=0; vertexNum < 4; ++vertexNum)
  2445.                                     rectangle[objectNum][vertexNum].x+=3.0;
  2446.                               }
  2447.                           }
  2448.                         break;
  2449.                       case 2:
  2450.                         xMod8=0;
  2451.                         for (objectNum=0; objectNum < 4; objectNum+=3)
  2452.                           for (vertexNum=0; vertexNum < 3; ++vertexNum)
  2453.                             {
  2454.                               triangle[objectNum][vertexNum].x
  2455.                                =baseTriangle[objectNum][vertexNum].x;
  2456.                               triangle[objectNum][vertexNum].y
  2457.                                =baseTriangle[objectNum][vertexNum].y+yOffset;
  2458.                             }
  2459.                         for (vertexNum=0; vertexNum < 4; ++vertexNum)
  2460.                           {
  2461.                             rectangle[4][vertexNum].x
  2462.                              =baseRectangle[4][vertexNum].x;
  2463.                             rectangle[4][vertexNum].y
  2464.                              =baseRectangle[4][vertexNum].y+yOffset;
  2465.                           }
  2466.                         for (x=0; x <= maxX; ++x)
  2467.                           {
  2468.                             switch (xMod8)
  2469.                               {
  2470.                                 case 0:
  2471.                                   singleTriangle[0].x=triangle[0][0].x;
  2472.                                   singleTriangle[0].y=triangle[0][0].y;
  2473.                                   singleTriangle[1].x=triangle[0][1].x;
  2474.                                   singleTriangle[1].y=triangle[0][1].y;
  2475.                                   singleTriangle[2].x=triangle[0][2].x;
  2476.                                   singleTriangle[2].y=triangle[0][2].y;
  2477.                                   outputTriangle(singleTriangle,true,
  2478.                                    TRIANGLE_SSW_NNE_COLOR);
  2479.                                   break;
  2480.                                 case 6:
  2481.                                   singleTriangle[0].x=triangle[3][0].x;
  2482.                                   singleTriangle[0].y=triangle[3][0].y;
  2483.                                   singleTriangle[1].x=triangle[3][1].x;
  2484.                                   singleTriangle[1].y=triangle[3][1].y;
  2485.                                   singleTriangle[2].x=triangle[3][2].x;
  2486.                                   singleTriangle[2].y=triangle[3][2].y;
  2487.                                   outputTriangle(singleTriangle,true,
  2488.                                    TRIANGLE_SSE_NNW_COLOR);
  2489.                                   break;
  2490.                                 default:
  2491.                                   break;
  2492.                               }
  2493.                             if (++xMod8 >= 8)
  2494.                               {
  2495.                                 xMod8=0;
  2496.                                 for (objectNum=0; objectNum < 4; objectNum+=3)
  2497.                                   for (vertexNum=0; vertexNum < 3; ++vertexNum)
  2498.                                     triangle[objectNum][vertexNum].x+=3.0;
  2499.                                 for (vertexNum=0; vertexNum < 4; ++vertexNum)
  2500.                                   rectangle[4][vertexNum].x+=3.0;
  2501.                               }
  2502.                           }
  2503.                         xMod8=0;
  2504.                         for (objectNum=0; objectNum < 4; objectNum+=3)
  2505.                           for (vertexNum=0; vertexNum < 3; ++vertexNum)
  2506.                             {
  2507.                               triangle[objectNum][vertexNum].x
  2508.                                =baseTriangle[objectNum][vertexNum].x;
  2509.                               triangle[objectNum][vertexNum].y
  2510.                                =baseTriangle[objectNum][vertexNum].y+yOffset;
  2511.                             }
  2512.                         for (vertexNum=0; vertexNum < 4; ++vertexNum)
  2513.                           {
  2514.                             rectangle[4][vertexNum].x
  2515.                              =baseRectangle[4][vertexNum].x;
  2516.                             rectangle[4][vertexNum].y
  2517.                              =baseRectangle[4][vertexNum].y+yOffset;
  2518.                           }
  2519.                         for (x=0; x <= maxX; ++x)
  2520.                           {
  2521.                             switch (xMod8)
  2522.                               {
  2523.                                 case 0:
  2524.                                   singleTriangle[0].x=triangle[0][0].x;
  2525.                                   singleTriangle[0].y=triangle[0][0].y;
  2526.                                   singleTriangle[1].x=triangle[0][1].x;
  2527.                                   singleTriangle[1].y=triangle[0][1].y;
  2528.                                   singleTriangle[2].x=triangle[0][2].x;
  2529.                                   singleTriangle[2].y=triangle[0][2].y;
  2530.                                   outputTriangle(singleTriangle,false,
  2531.                                    TRIANGLE_SW_NE_COLOR);
  2532.                                   break;
  2533.                                 case 6:
  2534.                                   singleTriangle[0].x=triangle[3][0].x;
  2535.                                   singleTriangle[0].y=triangle[3][0].y;
  2536.                                   singleTriangle[1].x=triangle[3][1].x;
  2537.                                   singleTriangle[1].y=triangle[3][1].y;
  2538.                                   singleTriangle[2].x=triangle[3][2].x;
  2539.                                   singleTriangle[2].y=triangle[3][2].y;
  2540.                                   outputTriangle(singleTriangle,false,
  2541.                                    TRIANGLE_SE_NW_COLOR);
  2542.                                   break;
  2543.                                 case 7:
  2544.                                   if (computerPage[y][x] == '\000')
  2545.                                     {
  2546.                                       singleRectangle[0].x=rectangle[4][0].x;
  2547.                                       singleRectangle[0].y=rectangle[4][0].y;
  2548.                                       singleRectangle[1].x=rectangle[4][1].x;
  2549.                                       singleRectangle[1].y=rectangle[4][1].y;
  2550.                                       singleRectangle[2].x=rectangle[4][2].x;
  2551.                                       singleRectangle[2].y=rectangle[4][2].y;
  2552.                                       singleRectangle[3].x=rectangle[4][3].x;
  2553.                                       singleRectangle[3].y=rectangle[4][3].y;
  2554.                                       outputRectangle(singleRectangle,
  2555.                                        RECTANGLE_W_E_COLOR);
  2556.                                     }
  2557.                                   break;
  2558.                                 default:
  2559.                                   break;
  2560.                               }
  2561.                             if (++xMod8 >= 8)
  2562.                               {
  2563.                                 xMod8=0;
  2564.                                 for (objectNum=0; objectNum < 4; objectNum+=3)
  2565.                                   for (vertexNum=0; vertexNum < 3; ++vertexNum)
  2566.                                     triangle[objectNum][vertexNum].x+=3.0;
  2567.                                 for (vertexNum=0; vertexNum < 4; ++vertexNum)
  2568.                                   rectangle[4][vertexNum].x+=3.0;
  2569.                               }
  2570.                           }
  2571.                         break;
  2572.                       default:
  2573.                         xMod8=0;
  2574.                         for (objectNum=0; objectNum < 6; objectNum+=5)
  2575.                           for (vertexNum=0; vertexNum < 4; ++vertexNum)
  2576.                             {
  2577.                               rectangle[objectNum][vertexNum].x
  2578.                                =baseRectangle[objectNum][vertexNum].x;
  2579.                               rectangle[objectNum][vertexNum].y
  2580.                                =baseRectangle[objectNum][vertexNum].y+yOffset;
  2581.                             }
  2582.                         for (x=0; x <= maxX; ++x)
  2583.                           {
  2584.                             switch (xMod8)
  2585.                               {
  2586.                                 case 1:
  2587.                                   if (computerPage[y][x] == '\000')
  2588.                                     {
  2589.                                       singleRectangle[0].x=rectangle[0][0].x;
  2590.                                       singleRectangle[0].y=rectangle[0][0].y;
  2591.                                       singleRectangle[1].x=rectangle[0][1].x;
  2592.                                       singleRectangle[1].y=rectangle[0][1].y;
  2593.                                       singleRectangle[2].x=rectangle[0][2].x;
  2594.                                       singleRectangle[2].y=rectangle[0][2].y;
  2595.                                       singleRectangle[3].x=rectangle[0][3].x;
  2596.                                       singleRectangle[3].y=rectangle[0][3].y;
  2597.                                       outputRectangle(singleRectangle,
  2598.                                        RECTANGLE_SE_NW_COLOR);
  2599.                                     }
  2600.                                   break;
  2601.                                 case 5:
  2602.                                   if (computerPage[y][x] == '\000')
  2603.                                     {
  2604.                                       singleRectangle[0].x=rectangle[5][0].x;
  2605.                                       singleRectangle[0].y=rectangle[5][0].y;
  2606.                                       singleRectangle[1].x=rectangle[5][1].x;
  2607.                                       singleRectangle[1].y=rectangle[5][1].y;
  2608.                                       singleRectangle[2].x=rectangle[5][2].x;
  2609.                                       singleRectangle[2].y=rectangle[5][2].y;
  2610.                                       singleRectangle[3].x=rectangle[5][3].x;
  2611.                                       singleRectangle[3].y=rectangle[5][3].y;
  2612.                                       outputRectangle(singleRectangle,
  2613.                                        RECTANGLE_SW_NE_COLOR);
  2614.                                     }
  2615.                                   break;
  2616.                                 default:
  2617.                                   break;
  2618.                               }
  2619.                             if (++xMod8 >= 8)
  2620.                               {
  2621.                                 xMod8=0;
  2622.                                 for (objectNum=0; objectNum < 6; objectNum+=5)
  2623.                                   for (vertexNum=0; vertexNum < 4; ++vertexNum)
  2624.                                     rectangle[objectNum][vertexNum].x+=3.0;
  2625.                               }
  2626.                           }
  2627.                         break;
  2628.                     }
  2629.                   if (++yMod4 >= 4)
  2630.                     {
  2631.                       yMod4=0;
  2632.                       yOffset+=sqrt3;
  2633.                     }
  2634.                   ++y;
  2635.                 }
  2636.               else
  2637.                 state=5;
  2638.               if (state == 5)
  2639.                 {
  2640.                   alreadyPainting=false;
  2641.                   hexDisplayUserMoves();
  2642.                   if (solutionDisplayed)
  2643.                     hexDisplaySolution();
  2644.                 }
  2645.               break;
  2646.             default:
  2647.               break;
  2648.           }
  2649.         return;
  2650.       }
  2651.  
  2652.     public void sqrKey(
  2653.       int deltaIndex1)
  2654.         {
  2655.           boolean passageFound;
  2656.           double  temDouble;
  2657.           int     xNext;
  2658.           double  xRelativeNext;
  2659.           int     yNext;
  2660.           double  yRelativeNext;
  2661.  
  2662.           yNext=0;
  2663.           xRelativeNext=0.0;
  2664.           yRelativeNext=0.0;
  2665.           passageFound=true;
  2666.           xNext=userX+sqrDeltaX[deltaIndex1][0];
  2667.           if (xNext <= 0)
  2668.             passageFound=false;
  2669.           else
  2670.             if (xNext >= maxX)
  2671.               passageFound=false;
  2672.             else
  2673.               yNext=userY+sqrDeltaY[deltaIndex1][0];
  2674.               if (yNext <= 0)
  2675.                 passageFound=false;
  2676.               else
  2677.                 if (yNext > maxY)
  2678.                   passageFound=false;
  2679.                 else
  2680.                   {
  2681.                     if (userPage[yNext][xNext] == '\000')
  2682.                       passageFound=false;
  2683.                   }
  2684.           if (passageFound)
  2685.             {
  2686.               xNext=xNext+sqrDeltaX[deltaIndex1][0];
  2687.               yNext=yNext+sqrDeltaY[deltaIndex1][0];
  2688.               if (yNext < maxY)
  2689.                 {
  2690.                   if (userPage[yNext][xNext] == '\001')
  2691.                     {
  2692.                       graph.setColor(redGreenBlue[BACKOUT_COLOR]);
  2693.                       userPage[userY][userX]='\003';
  2694.                     }
  2695.                   else
  2696.                     {
  2697.                       graph.setColor(redGreenBlue[ADVANCE_COLOR]);
  2698.                       userPage[yNext][xNext]='\001';
  2699.                     }
  2700.                   temDouble=(double) sqrDeltaX[deltaIndex1][0];
  2701.                   xRelativeNext=userXRelative+temDouble;
  2702.                   temDouble=(double) sqrDeltaY[deltaIndex1][0];
  2703.                   yRelativeNext=userYRelative+temDouble;
  2704.                   drawLine(userXRelative,userYRelative,xRelativeNext,
  2705.                    yRelativeNext);
  2706.                 }
  2707.               else
  2708.                 {
  2709.                   graph.setColor(redGreenBlue[ADVANCE_COLOR]);
  2710.                   drawLine(userXRelative,userYRelative,userXRelative,yMax);
  2711.                   userHasSolved=true;
  2712.                 }
  2713.               userX=xNext;
  2714.               userY=yNext;
  2715.               userXRelative=xRelativeNext;
  2716.               userYRelative=yRelativeNext;
  2717.             }
  2718.         }
  2719.  
  2720.     public void sqrDisplayUserMoves()
  2721.       {
  2722.         int    deltaIndex;
  2723.         double temDouble;
  2724.         int    x;
  2725.         int    xNext;
  2726.         int    xNextNext;
  2727.         double xRelative;
  2728.         double xRelativeNext;
  2729.         int    y;
  2730.         int    yNext;
  2731.         int    yNextNext;
  2732.         double yRelative;
  2733.         double yRelativeNext;
  2734.  
  2735.         xRelative=0.0;
  2736.         y=1;
  2737.         yRelative=(RELATIVE_WIDTH_OF_WALL+1.0)/2.0;
  2738.         while (y < maxY)
  2739.           {
  2740.             x=1;
  2741.             xRelative=(RELATIVE_WIDTH_OF_WALL+1.0)/2.0;
  2742.             while (x < maxX)
  2743.               {
  2744.                 if ((userPage[y][x] == '\001')
  2745.                 ||  (userPage[y][x] == '\003'))
  2746.                   for (deltaIndex=0; deltaIndex < 4; ++deltaIndex)
  2747.                     {
  2748.                       xNext=x+sqrDeltaX[deltaIndex][0];
  2749.                       yNext=y+sqrDeltaY[deltaIndex][0];
  2750.                       if (userPage[yNext][xNext] != '\000')
  2751.                         {
  2752.                           if (yNext == 0)
  2753.                             {
  2754.                               graph.setColor(redGreenBlue[ADVANCE_COLOR]);
  2755.                               drawLine(xRelative,RELATIVE_WIDTH_OF_WALL/2.0,
  2756.                                xRelative,yRelative);
  2757.                             }
  2758.                           else
  2759.                             if (yNext == maxY)
  2760.                               {
  2761.                                 if (userHasSolved)
  2762.                                   {
  2763.                                     graph.setColor(redGreenBlue[ADVANCE_COLOR]);
  2764.                                     drawLine(xRelative,yRelative,xRelative,
  2765.                                      yMax);
  2766.                                   }
  2767.                               }
  2768.                             else
  2769.                               {
  2770.                                 xNextNext=xNext+sqrDeltaX[deltaIndex][0];
  2771.                                 if (xNextNext > 0)
  2772.                                   {
  2773.                                     if (xNextNext < maxX)
  2774.                                       {
  2775.                                         yNextNext
  2776.                                          =yNext+sqrDeltaY[deltaIndex][0];
  2777.                                         if (yNextNext > 0)
  2778.                                           {
  2779.                                             if (yNextNext < maxY)
  2780.                                               {
  2781.                                                 if ((userPage[yNextNext][
  2782.                                                  xNextNext] == '\001') 
  2783.                                                 ||  (userPage[yNextNext][
  2784.                                                  xNextNext] == '\003'))
  2785.                                                   { 
  2786.                                                     if (userPage[y][x]
  2787.                                                      == userPage[yNextNext][
  2788.                                                      xNextNext])
  2789.                                                       if (userPage[y][x]
  2790.                                                        == '\001')
  2791.                                                         graph.setColor(
  2792.                                                          redGreenBlue[
  2793.                                                          ADVANCE_COLOR]);
  2794.                                                       else
  2795.                                                         graph.setColor(
  2796.                                                          redGreenBlue[
  2797.                                                          BACKOUT_COLOR]);
  2798.                                                     else
  2799.                                                       graph.setColor(
  2800.                                                        redGreenBlue[
  2801.                                                        BACKOUT_COLOR]);
  2802.                                                     temDouble=(double)
  2803.                                                      sqrDeltaX[deltaIndex][0];
  2804.                                                     xRelativeNext=xRelative
  2805.                                                      +temDouble/2.0;
  2806.                                                     temDouble=(double)
  2807.                                                      sqrDeltaY[deltaIndex][0];
  2808.                                                     yRelativeNext=yRelative
  2809.                                                      +temDouble/2.0;
  2810.                                                     drawLine(xRelative,
  2811.                                                      yRelative,xRelativeNext,
  2812.                                                      yRelativeNext);
  2813.                                                   }
  2814.                                              }
  2815.                                           }
  2816.                                       }
  2817.                                   }
  2818.                               }
  2819.                         }
  2820.                     }
  2821.                 ++xRelative;
  2822.                 x+=2;
  2823.               }
  2824.             ++yRelative;
  2825.             y+=2;
  2826.           }
  2827.         if (userHasSolved)
  2828.           {
  2829.             graph.setColor(redGreenBlue[ADVANCE_COLOR]);
  2830.             drawLine(xRelative,yRelative,xRelative,yMax);
  2831.           }
  2832.       }
  2833.  
  2834.     private void sqrSolveMaze()
  2835.         {
  2836.           int     deltaIndex;
  2837.           boolean passageFound;
  2838.           int     stackHead;
  2839.           int     x;
  2840.           int     xNext;
  2841.           int     y;
  2842.           int     yNext;
  2843.         
  2844.           numRoomsInSolution=1;
  2845.           adjacency=0;
  2846.           x=1;
  2847.           y=1;
  2848.           stackHead=-1;
  2849.           computerPage[y][x]='\001';
  2850.           yNext=0;
  2851.           xNext=0;
  2852.           do
  2853.             {
  2854.               deltaIndex=0;
  2855.               passageFound=false;
  2856.               do
  2857.                 {
  2858.                   while ((deltaIndex < 4) && (! passageFound))
  2859.                     {
  2860.                       xNext=x+sqrDeltaX[deltaIndex][0];
  2861.                       yNext=y+sqrDeltaY[deltaIndex][0];
  2862.                       if (computerPage[yNext][xNext] == '\002')
  2863.                         passageFound=true;
  2864.                       else
  2865.                         ++deltaIndex;
  2866.                     }
  2867.                   if (! passageFound)
  2868.                     {
  2869.                       deltaIndex=stack[stackHead].index1;
  2870.                       computerPage[y][x]='\002';
  2871.                       x-=sqrDeltaX[deltaIndex][0];
  2872.                       y-=sqrDeltaY[deltaIndex][0];
  2873.                       computerPage[y][x]='\002';
  2874.                       x-=sqrDeltaX[deltaIndex][0];
  2875.                       y-=sqrDeltaY[deltaIndex][0];
  2876.                       --stackHead;
  2877.                       ++deltaIndex;
  2878.                     }
  2879.                 }
  2880.               while (! passageFound);
  2881.               computerPage[yNext][xNext]='\001';
  2882.               xNext+=sqrDeltaX[deltaIndex][0];
  2883.               yNext+=sqrDeltaY[deltaIndex][0];
  2884.               if (yNext <= maxY)
  2885.                 {
  2886.                   stack[++stackHead].index1=(short) deltaIndex;
  2887.                   computerPage[yNext][xNext]='\001';
  2888.                   x=xNext;
  2889.                   y=yNext;
  2890.                 }
  2891.             }
  2892.           while (yNext < maxY);
  2893.           x=maxX-1;
  2894.           y=maxY-1;
  2895.           adjacency=0;
  2896.           while (stackHead >= 0)
  2897.             {
  2898.               for (deltaIndex=0; deltaIndex < 4; ++deltaIndex)
  2899.                 {
  2900.                   xNext=x+sqrDeltaX[deltaIndex][0];
  2901.                   yNext=y+sqrDeltaY[deltaIndex][0];
  2902.                   if (computerPage[yNext][xNext] != '\001')
  2903.                     {
  2904.                       if (computerPage[yNext][xNext] == '\000')
  2905.                         {
  2906.                           xNext+=sqrDeltaX[deltaIndex][0];
  2907.                           yNext+=sqrDeltaY[deltaIndex][0];
  2908.                           if (xNext < 0)
  2909.                             ++adjacency;
  2910.                           else
  2911.                             if (xNext > maxX)
  2912.                               ++adjacency;
  2913.                             else
  2914.                               if (yNext < 0)
  2915.                                 ++adjacency;
  2916.                               else
  2917.                                 if (yNext > maxY)
  2918.                                   ++adjacency;
  2919.                                 else
  2920.                                   {
  2921.                                     if (computerPage[yNext][xNext] == '\001')
  2922.                                       ++adjacency;
  2923.                                   }
  2924.                         }
  2925.                     }
  2926.                 }
  2927.               x-=2*sqrDeltaX[stack[stackHead].index1][0];
  2928.               y-=2*sqrDeltaY[stack[stackHead--].index1][0];
  2929.               ++numRoomsInSolution;
  2930.             }
  2931.           for (deltaIndex=0; deltaIndex < 4; ++deltaIndex)
  2932.             {
  2933.               xNext=x+sqrDeltaX[deltaIndex][0];
  2934.               yNext=x+sqrDeltaY[deltaIndex][0];
  2935.               if (computerPage[yNext][xNext] != '\002')
  2936.                 {
  2937.                   if (computerPage[yNext][xNext] == '\000')
  2938.                     {
  2939.                       xNext+=sqrDeltaX[deltaIndex][0];
  2940.                       yNext+=sqrDeltaY[deltaIndex][0];
  2941.                       if (xNext < 0)
  2942.                         ++adjacency;
  2943.                       else
  2944.                         if (xNext > maxX)
  2945.                           ++adjacency;
  2946.                         else
  2947.                           if (yNext < 0)
  2948.                             ++adjacency;
  2949.                           else
  2950.                             if (yNext > maxY)
  2951.                               ++adjacency;
  2952.                             else
  2953.                               {
  2954.                                 if (computerPage[yNext][xNext] == '\001')
  2955.                                   ++adjacency;
  2956.                               }
  2957.                     }
  2958.                 }
  2959.             }
  2960.           return;
  2961.         }
  2962.     
  2963.     private void sqrGenerateMaze(
  2964.       int      seed [])
  2965.         {
  2966.           int     deltaIndex1;
  2967.           int     deltaIndex2;
  2968.           int     digit;
  2969.           int     digitNum;
  2970.           boolean passageFound;
  2971.           int     rN [];
  2972.           int     rNIndex1;
  2973.           int     rNIndex2;
  2974.           boolean searchComplete;
  2975.           int     stackHead;
  2976.           int     sum;
  2977.           int     temInt;
  2978.           int     x;
  2979.           int     xNext;
  2980.           int     y;
  2981.           int     yNext;
  2982.         
  2983.           yNext=0;
  2984.           xNext=0;
  2985.           rN=new int [8];
  2986.           rN[0]=seed[0]+1;
  2987.           rN[1]=seed[1]+1;
  2988.           rN[2]=seed[2]+1;
  2989.           rN[3]=seed[3]+1;
  2990.           rN[4]=seed[4]+1;
  2991.           rN[5]=seed[5]+1;
  2992.           rN[6]=seed[6]+1;
  2993.           rN[7]=seed[7]+1;
  2994.           for (y=0; y <= maxY; ++y)
  2995.             for (x=0; x <= maxX; ++x)
  2996.               computerPage[y][x]='\000';
  2997.           sum=0;
  2998.           for (digitNum=1; digitNum <= 3; ++digitNum)
  2999.             {
  3000.               digit=rN[0];
  3001.               rNIndex1=0;
  3002.               rNIndex2=1;
  3003.               while (rNIndex2 < 8)
  3004.                 {
  3005.                   temInt=rN[rNIndex2];
  3006.                   rN[rNIndex1]=temInt;
  3007.                   digit+=temInt;
  3008.                   if (digit >= 29)
  3009.                     digit-=29;
  3010.                   rNIndex1=rNIndex2++;
  3011.                 }
  3012.               rN[7]=digit;
  3013.               sum=29*sum+digit;
  3014.             }
  3015.           x=2*(sum%numColumns)+1;
  3016.           sum=0;
  3017.           for (digitNum=1; digitNum <= 3; ++digitNum)
  3018.             {
  3019.               digit=rN[0];
  3020.               rNIndex1=0;
  3021.               rNIndex2=1;
  3022.               while (rNIndex2 < 8)
  3023.                 {
  3024.                   temInt=rN[rNIndex2];
  3025.                   rN[rNIndex1]=temInt;
  3026.                   digit+=temInt;
  3027.                   if (digit >= 29)
  3028.                     digit-=29;
  3029.                   rNIndex1=rNIndex2++;
  3030.                 }
  3031.               rN[7]=digit;
  3032.               sum=29*sum+digit;
  3033.             }
  3034.           y=2*(sum%numRows)+1;
  3035.           computerPage[y][x]='\002';
  3036.           stackHead=-1;
  3037.           do
  3038.             {
  3039.               deltaIndex1=0;
  3040.               do
  3041.                 {
  3042.                   deltaIndex2=rN[0];
  3043.                   rNIndex1=0;
  3044.                   rNIndex2=1;
  3045.                   while (rNIndex2 < 8)
  3046.                     {
  3047.                       temInt=rN[rNIndex2];
  3048.                       rN[rNIndex1]=temInt;
  3049.                       deltaIndex2+=temInt;
  3050.                       if (deltaIndex2 >= 29) 
  3051.                         deltaIndex2-=29;
  3052.                       rNIndex1=rNIndex2++;
  3053.                     }
  3054.                   rN[7]=deltaIndex2;
  3055.                 }
  3056.               while (deltaIndex2 >= 24);
  3057.               passageFound=false;
  3058.               searchComplete=false;
  3059.               while (! searchComplete)
  3060.                 {
  3061.                   while ((deltaIndex1 < 4) && (! passageFound))
  3062.                     {
  3063.                       xNext=x+2*sqrDeltaX[deltaIndex1][deltaIndex2];
  3064.                       if (xNext <= 0)
  3065.                         ++deltaIndex1;
  3066.                       else
  3067.                         if (xNext > maxX)
  3068.                           ++deltaIndex1;
  3069.                         else
  3070.                           {
  3071.                             yNext=y+2*sqrDeltaY[deltaIndex1][deltaIndex2];
  3072.                             if (yNext <= 0)
  3073.                               ++deltaIndex1;
  3074.                             else
  3075.                               if (yNext > maxY)
  3076.                                 ++deltaIndex1;
  3077.                               else
  3078.                                 if (computerPage[yNext][xNext] == '\000')
  3079.                                   passageFound=true;
  3080.                                 else
  3081.                                   ++deltaIndex1;
  3082.                           }
  3083.                     }
  3084.                   if (! passageFound)
  3085.                     {
  3086.                       if (stackHead >= 0)
  3087.                         {
  3088.                           deltaIndex1=stack[stackHead].index1;
  3089.                           deltaIndex2=stack[stackHead--].index2;
  3090.                           x-=2*sqrDeltaX[deltaIndex1][deltaIndex2];
  3091.                           y-=2*sqrDeltaY[deltaIndex1++][deltaIndex2];
  3092.                         }
  3093.                     }
  3094.                   searchComplete
  3095.                    =(passageFound || ((stackHead == -1) && (deltaIndex1 >= 4)));
  3096.                 }
  3097.               if (passageFound)
  3098.                 {
  3099.                   stack[++stackHead].index1=(short) deltaIndex1;
  3100.                   stack[stackHead].index2=(short) deltaIndex2;
  3101.                   computerPage[yNext][xNext]='\002';
  3102.                   computerPage[(y+yNext)/2][(x+xNext)/2]='\002';
  3103.                   x=xNext;
  3104.                   y=yNext;
  3105.                 }
  3106.             }
  3107.           while (stackHead != -1);
  3108.           computerPage[0][1]='\001';
  3109.           computerPage[maxY][maxX-1]='\002';
  3110.           return;
  3111.         }
  3112.     
  3113.     private void sqrSelectMaze()
  3114.         {
  3115.           int    adjacency;
  3116.           int    counter0;
  3117.           int    counter1;
  3118.           int    counter2;
  3119.           int    counter3;
  3120.           int    counter4;
  3121.           int    counter5;
  3122.           int    counter6;
  3123.           int    counter7;
  3124.           Date   today;
  3125.           double elapsedTime;
  3126.           int    minAdjacency;
  3127.           int    numRoomsInSolution;
  3128.           int    numRoomsInSolutionAtMin;
  3129.           int    seedByte [];
  3130.           int    seedByteAtMin [];
  3131.           double startTime;
  3132.         
  3133.           adjacency=0;
  3134.           numRoomsInSolution=0;
  3135.           seedByte=new int [8];
  3136.           seedByteAtMin=new int [8];
  3137.           counter0=seed[0];
  3138.           counter1=seed[1];
  3139.           counter2=seed[2];
  3140.           counter3=seed[3];
  3141.           counter4=seed[4];
  3142.           counter5=seed[5];
  3143.           counter6=seed[6];
  3144.           counter7=seed[7];
  3145.           hash();
  3146.           minAdjacency=2*numRoomsInMaze+1;
  3147.           numRoomsInSolutionAtMin=0;
  3148.           seedByteAtMin[0]=counter0;
  3149.           seedByteAtMin[1]=counter1;
  3150.           seedByteAtMin[2]=counter2;
  3151.           seedByteAtMin[3]=counter3;
  3152.           seedByteAtMin[4]=counter4;
  3153.           seedByteAtMin[5]=counter5;
  3154.           seedByteAtMin[6]=counter6;
  3155.           seedByteAtMin[7]=counter7;
  3156.           today=new Date();
  3157.           startTime=((double) today.getTime())/1000.0;
  3158.           do
  3159.             {
  3160.               seedByte[0]=counter0;
  3161.               seedByte[1]=counter1;
  3162.               seedByte[2]=counter2;
  3163.               seedByte[3]=counter3;
  3164.               seedByte[4]=counter4;
  3165.               seedByte[5]=counter5;
  3166.               seedByte[6]=counter6;
  3167.               seedByte[7]=counter7;
  3168.               sqrGenerateMaze(seedByte);
  3169.               sqrSolveMaze();
  3170.               if (3*numRoomsInSolution >= numRoomsInMaze)
  3171.                 {
  3172.                   if (adjacency < minAdjacency)
  3173.                     {
  3174.                       minAdjacency=adjacency;
  3175.                       numRoomsInSolutionAtMin=numRoomsInSolution;
  3176.                       seedByteAtMin[0]=seedByte[0];
  3177.                       seedByteAtMin[1]=seedByte[1];
  3178.                       seedByteAtMin[2]=seedByte[2];
  3179.                       seedByteAtMin[3]=seedByte[3];
  3180.                       seedByteAtMin[4]=seedByte[4];
  3181.                       seedByteAtMin[5]=seedByte[5];
  3182.                       seedByteAtMin[6]=seedByte[6];
  3183.                       seedByteAtMin[7]=seedByte[7];
  3184.                     }
  3185.                   else
  3186.                     {
  3187.                       if (adjacency == minAdjacency)
  3188.                         {
  3189.                           if (numRoomsInSolution > numRoomsInSolutionAtMin)
  3190.                             {
  3191.                               numRoomsInSolutionAtMin=numRoomsInSolution;
  3192.                               seedByteAtMin[0]=seedByte[0];
  3193.                               seedByteAtMin[1]=seedByte[1];
  3194.                               seedByteAtMin[2]=seedByte[2];
  3195.                               seedByteAtMin[3]=seedByte[3];
  3196.                               seedByteAtMin[4]=seedByte[4];
  3197.                               seedByteAtMin[5]=seedByte[5];
  3198.                               seedByteAtMin[6]=seedByte[6];
  3199.                               seedByteAtMin[7]=seedByte[7];
  3200.                             }
  3201.                         }
  3202.                     }
  3203.                 }
  3204.               increment();
  3205.               today=new Date();
  3206.               elapsedTime=((double) today.getTime())/1000.0-startTime;
  3207.             }
  3208.           while ((elapsedTime >= 0.0)
  3209.           &&     (elapsedTime < SECONDS_FOR_MAZE_SELECTION));
  3210.           sqrGenerateMaze(seedByteAtMin);
  3211.           sqrSolveMaze();
  3212.           return;
  3213.         }
  3214.  
  3215.      public void sqrDisplaySolution()
  3216.         {
  3217.           int     deltaIndex;
  3218.           boolean pathFound;
  3219.           double  temDouble;
  3220.           int     x;
  3221.           int     xNext;
  3222.           int     xPrevious;
  3223.           double  xRelative;
  3224.           double  xRelativeNext;
  3225.           int     y;
  3226.           int     yNext;
  3227.           int     yPrevious;
  3228.           double  yRelative;
  3229.           double  yRelativeNext;
  3230.  
  3231.           xRelative=(RELATIVE_WIDTH_OF_WALL+1.0)/2.0;
  3232.           yRelative=(RELATIVE_WIDTH_OF_WALL+1.0)/2.0;
  3233.           xRelativeNext=0.0;
  3234.           yRelativeNext=0.0;
  3235.           graph.setColor(redGreenBlue[SOLUTION_COLOR]);
  3236.           drawLine(xRelative,RELATIVE_WIDTH_OF_WALL/2.0,xRelative,yRelative);
  3237.           xPrevious=1;
  3238.           yPrevious=-1;
  3239.           x=1;
  3240.           y=1;
  3241.           xNext=0;
  3242.           yNext=0;
  3243.           do
  3244.             {
  3245.               pathFound=false;
  3246.               deltaIndex=0;
  3247.               while (! pathFound)
  3248.                 {
  3249.                   xNext=x+sqrDeltaX[deltaIndex][0];
  3250.                   yNext=y+sqrDeltaY[deltaIndex][0];
  3251.                   if (computerPage[yNext][xNext] == '\001')
  3252.                     {
  3253.                       xNext+=sqrDeltaX[deltaIndex][0];
  3254.                       yNext+=sqrDeltaY[deltaIndex][0];
  3255.                       if ((xNext != xPrevious) || (yNext != yPrevious))
  3256.                         pathFound=true;
  3257.                       else
  3258.                         ++deltaIndex;
  3259.                     }
  3260.                   else
  3261.                     ++deltaIndex;
  3262.                 }
  3263.               if (yNext < maxY)
  3264.                 {
  3265.                   temDouble=(double) (sqrDeltaX[deltaIndex][0]);
  3266.                   xRelativeNext=xRelative+temDouble;
  3267.                   temDouble=sqrDeltaY[deltaIndex][0];
  3268.                   yRelativeNext=yRelative+temDouble;
  3269.                   drawLine(xRelative,yRelative,xRelativeNext,yRelativeNext);
  3270.                 }
  3271.               else
  3272.                 drawLine(xRelative,yRelative,xRelative,yMax);
  3273.               xPrevious=x;
  3274.               yPrevious=y;
  3275.               x=xNext;
  3276.               y=yNext;
  3277.               xRelative=xRelativeNext;
  3278.               yRelative=yRelativeNext;
  3279.             }
  3280.           while (yNext < maxY);
  3281.           return;
  3282.         }
  3283.  
  3284.     
  3285.     private void sqrOutputMaze()
  3286.       {
  3287.         int       cornerX [];
  3288.         int       cornerY [];
  3289.         int       digitNum;
  3290.         long      dividend;
  3291.         int       objectNum;
  3292.         long      quotient;
  3293.         double    radians;
  3294.         double    radiansPerDegree;
  3295.         int       roomNum;
  3296.         VertexRec singleRectangle [];
  3297.         double    temDouble1;
  3298.         double    temDouble2;
  3299.         double    temDouble3;
  3300.         Date      today;
  3301.         int       vertexNum;
  3302.         double    x0;
  3303.         double    x1;
  3304.         double    x2;
  3305.         double    x3;
  3306.         double    y0;
  3307.         double    y1;
  3308.         double    y2;
  3309.         double    y3;
  3310.       
  3311.         singleRectangle=new VertexRec [4];
  3312.         for (vertexNum=0; vertexNum < 4; ++vertexNum)
  3313.           singleRectangle[vertexNum]=new VertexRec();
  3314.         switch (state)
  3315.           {
  3316.             case 0:
  3317.               if (resize)
  3318.                 {
  3319.                   seed=new int [8];
  3320.                   today=new Date();
  3321.                   dividend=today.getTime();
  3322.                   for (digitNum=0; digitNum < 8; ++digitNum)
  3323.                     {
  3324.                       quotient=dividend/10;
  3325.                       seed[digitNum]=(int) (dividend-10*quotient);
  3326.                       dividend=quotient;
  3327.                     }
  3328.                   temDouble1=((double) (screen.width))*0.28;
  3329.                   temDouble2=(double) MIN_WALL_LENGTH_IN_INCHES;
  3330.                   temDouble2*=25.4;
  3331.                   temDouble3=(double) RELATIVE_WIDTH_OF_WALL;
  3332.                   numColumns=(int) (temDouble1/temDouble2-temDouble3);
  3333.                   if (numColumns < 2) 
  3334.                     numColumns=2;
  3335.                   temDouble1=((double) (screen.height))*0.28;
  3336.                   temDouble2=((double) (screen.width))*0.28;
  3337.                   temDouble3=(double) numColumns;
  3338.                   numRows=(int) ((temDouble1*temDouble3)/temDouble2);
  3339.                   if (numRows < 2)
  3340.                     numRows=2;
  3341.                   maxX=2*numColumns;
  3342.                   maxY=2*numRows;
  3343.                   numRoomsInMaze=numRows*numColumns;
  3344.                   computerPage=new char [maxY+1] [maxX+1];
  3345.                   userPage=new char [maxY+1] [maxX+1];
  3346.                   clearUserAttempts=true;
  3347.                   stack=new StackRec [numRoomsInMaze];
  3348.                   for (roomNum=0; roomNum < numRoomsInMaze; ++roomNum)
  3349.                     stack[roomNum]=new StackRec();
  3350.                   sqrSelectMaze();
  3351.                   resize=false;
  3352.                 }
  3353.               if (clearUserAttempts)
  3354.                 {
  3355.                   for (userX=0; userX <= maxX; ++userX)
  3356.                     for (userY=0; userY <= maxY; ++userY)
  3357.                       if (computerPage[userY][userX] == '\000')
  3358.                         userPage[userY][userX]='\000';
  3359.                       else
  3360.                         userPage[userY][userX]='\002';
  3361.                   userX=1;
  3362.                   userXRelative=(RELATIVE_WIDTH_OF_WALL+1.0)/2.0;
  3363.                   userY=1;
  3364.                   userYRelative=(RELATIVE_WIDTH_OF_WALL+1.0)/2.0;
  3365.                   userPage[userY][userX]='\001';
  3366.                   clearUserAttempts=false;
  3367.                 }
  3368.               if (paint)
  3369.                 {
  3370.                   cornerX=new int [4];
  3371.                   cornerY=new int [4];
  3372.                   cornerX[0]=0;
  3373.                   cornerY[0]=0;
  3374.                   cornerX[1]=0;
  3375.                   cornerY[1]=screen.height;
  3376.                   cornerX[2]=screen.width;
  3377.                   cornerY[2]=screen.height;
  3378.                   cornerX[3]=screen.width;
  3379.                   cornerY[3]=0;
  3380.                   graph.setColor(new Color(255,255,255));
  3381.                   graph.fillPolygon(cornerX,cornerY,4);
  3382.                   radiansPerDegree=Math.atan(1.0)/45.0;
  3383.                   radians=tilt*radiansPerDegree;
  3384.                   sinTilt=Math.sin(radians);
  3385.                   cosTilt=Math.cos(radians);
  3386.                   temDouble1=(double) numColumns;
  3387.                   xMax=temDouble1+RELATIVE_WIDTH_OF_WALL;
  3388.                   temDouble1=(double) (screen.width);
  3389.                   pixelsPerX=(temDouble1-1.0)
  3390.                    /(xMax*(xMax/(xMax-RELATIVE_HEIGHT_OF_WALL)));
  3391.                   xOffset=(xMax/2.0)
  3392.                    *(RELATIVE_HEIGHT_OF_WALL/(xMax-RELATIVE_HEIGHT_OF_WALL));
  3393.                   temDouble1=(double) numRows;
  3394.                   yMax=temDouble1+RELATIVE_WIDTH_OF_WALL;
  3395.                   temDouble1=(double) (screen.height);
  3396.                   pixelsPerZ=(temDouble1-1.0)/Math.sqrt(yMax*yMax
  3397.                    +RELATIVE_HEIGHT_OF_WALL*RELATIVE_HEIGHT_OF_WALL);
  3398.                   if (yMax > xMax)
  3399.                     relDistOfUserFromScreen=yMax;
  3400.                   else
  3401.                     relDistOfUserFromScreen=xMax;
  3402.                   paint=false;
  3403.                 }
  3404.               if (state == 0)
  3405.                 state=1;
  3406.               break;
  3407.             case 1:
  3408.               baseRectangle[0][0].x=0.0;
  3409.               baseRectangle[0][0].y=0.0;
  3410.               baseRectangle[0][1].x=RELATIVE_WIDTH_OF_WALL;
  3411.               baseRectangle[0][1].y=0.0;
  3412.               baseRectangle[0][2].x=RELATIVE_WIDTH_OF_WALL;
  3413.               baseRectangle[0][2].y=RELATIVE_WIDTH_OF_WALL;
  3414.               baseRectangle[0][3].x=0.0;
  3415.               baseRectangle[0][3].y=RELATIVE_WIDTH_OF_WALL;
  3416.               baseRectangle[1][0].x=RELATIVE_WIDTH_OF_WALL;
  3417.               baseRectangle[1][0].y=0.0;
  3418.               baseRectangle[1][1].x=1.0;
  3419.               baseRectangle[1][1].y=0.0;
  3420.               baseRectangle[1][2].x=1.0;
  3421.               baseRectangle[1][2].y=RELATIVE_WIDTH_OF_WALL;
  3422.               baseRectangle[1][3].x=RELATIVE_WIDTH_OF_WALL;
  3423.               baseRectangle[1][3].y=RELATIVE_WIDTH_OF_WALL;
  3424.               baseRectangle[2][0].x=RELATIVE_WIDTH_OF_WALL;
  3425.               baseRectangle[2][0].y=RELATIVE_WIDTH_OF_WALL;
  3426.               baseRectangle[2][1].x=1.0;
  3427.               baseRectangle[2][1].y=RELATIVE_WIDTH_OF_WALL;
  3428.               baseRectangle[2][2].x=1.0;
  3429.               baseRectangle[2][2].y=1.0;
  3430.               baseRectangle[2][3].x=RELATIVE_WIDTH_OF_WALL;
  3431.               baseRectangle[2][3].y=1.0;
  3432.               baseRectangle[3][0].x=0.0;
  3433.               baseRectangle[3][0].y=RELATIVE_WIDTH_OF_WALL;
  3434.               baseRectangle[3][1].x=RELATIVE_WIDTH_OF_WALL;
  3435.               baseRectangle[3][1].y=RELATIVE_WIDTH_OF_WALL;
  3436.               baseRectangle[3][2].x=RELATIVE_WIDTH_OF_WALL;
  3437.               baseRectangle[3][2].y=1.0;
  3438.               baseRectangle[3][3].x=0.0;
  3439.               baseRectangle[3][3].y=1.0;
  3440.               rectangle[0][0].x=0.0;
  3441.               rectangle[0][0].y=0.0;
  3442.               rectangle[0][1].x=xMax;
  3443.               rectangle[0][1].y=0.0;
  3444.               rectangle[0][2].x=xMax;
  3445.               rectangle[0][2].y=yMax;
  3446.               rectangle[0][3].x=0.0;
  3447.               rectangle[0][3].y=yMax;
  3448.               x0=rectangle[0][0].x;
  3449.               y0=rectangle[0][0].y;
  3450.               x1=rectangle[0][1].x;
  3451.               y1=rectangle[0][1].y;
  3452.               x2=rectangle[0][2].x;
  3453.               y2=rectangle[0][2].y;
  3454.               x3=rectangle[0][3].x;
  3455.               y3=rectangle[0][3].y;
  3456.               displayQuadrilateral(x0,y0,0.0,x1,y1,0.0,x2,y2,0.0,x3,y3,0.0,
  3457.                FLOOR_COLOR);
  3458.               y=0;
  3459.               yOffset=0;
  3460.               state=4;
  3461.               break;
  3462.             case 4:
  3463.               if (y <= maxY)
  3464.                 {
  3465.                   for (vertexNum=0; vertexNum < 4; ++vertexNum)
  3466.                     {
  3467.                       rectangle[0][vertexNum].x=baseRectangle[0][vertexNum].x;
  3468.                       rectangle[0][vertexNum].y
  3469.                        =baseRectangle[0][vertexNum].y+yOffset;
  3470.                     }
  3471.                   x=0;
  3472.                   while (x <= maxX)
  3473.                     {
  3474.                       if (computerPage[y][x] == '\000')
  3475.                         {
  3476.                           singleRectangle[0].x=rectangle[0][0].x;
  3477.                           singleRectangle[0].y=rectangle[0][0].y;
  3478.                           singleRectangle[1].x=rectangle[0][1].x;
  3479.                           singleRectangle[1].y=rectangle[0][1].y;
  3480.                           singleRectangle[2].x=rectangle[0][2].x;
  3481.                           singleRectangle[2].y=rectangle[0][2].y;
  3482.                           singleRectangle[3].x=rectangle[0][3].x;
  3483.                           singleRectangle[3].y=rectangle[0][3].y;
  3484.                           outputLeftRight(singleRectangle);
  3485.                         }
  3486.                       for (vertexNum=0; vertexNum < 4; ++vertexNum)
  3487.                         ++rectangle[0][vertexNum].x;
  3488.                       x+=2;
  3489.                     }
  3490.                   for (vertexNum=0; vertexNum < 4; ++vertexNum)
  3491.                     {
  3492.                       rectangle[0][vertexNum].x=baseRectangle[0][vertexNum].x;
  3493.                       rectangle[0][vertexNum].y
  3494.                        =baseRectangle[0][vertexNum].y+yOffset;
  3495.                     }
  3496.                   for (vertexNum=0; vertexNum < 4; ++vertexNum)
  3497.                     {
  3498.                       rectangle[1][vertexNum].x=baseRectangle[1][vertexNum].x;
  3499.                       rectangle[1][vertexNum].y
  3500.                        =baseRectangle[1][vertexNum].y+yOffset;
  3501.                     }
  3502.                   x=0;
  3503.                   while (x <= maxX)
  3504.                     {
  3505.                       if (computerPage[y][x] == '\000')
  3506.                         {
  3507.                           singleRectangle[0].x=rectangle[0][0].x;
  3508.                           singleRectangle[0].y=rectangle[0][0].y;
  3509.                           singleRectangle[1].x=rectangle[0][1].x;
  3510.                           singleRectangle[1].y=rectangle[0][1].y;
  3511.                           singleRectangle[2].x=rectangle[0][2].x;
  3512.                           singleRectangle[2].y=rectangle[0][2].y;
  3513.                           singleRectangle[3].x=rectangle[0][3].x;
  3514.                           singleRectangle[3].y=rectangle[0][3].y;
  3515.                           outputRectangle(singleRectangle,
  3516.                            RECTANGLE_W_E_COLOR);
  3517.                         }
  3518.                       for (vertexNum=0; vertexNum < 4; ++vertexNum)
  3519.                         ++rectangle[0][vertexNum].x;
  3520.                       ++x;
  3521.                       if (x <= maxX)
  3522.                         {
  3523.                           if (computerPage[y][x] == '\000')
  3524.                             {
  3525.                               singleRectangle[0].x=rectangle[1][0].x;
  3526.                               singleRectangle[0].y=rectangle[1][0].y;
  3527.                               singleRectangle[1].x=rectangle[1][1].x;
  3528.                               singleRectangle[1].y=rectangle[1][1].y;
  3529.                               singleRectangle[2].x=rectangle[1][2].x;
  3530.                               singleRectangle[2].y=rectangle[1][2].y;
  3531.                               singleRectangle[3].x=rectangle[1][3].x;
  3532.                               singleRectangle[3].y=rectangle[1][3].y;
  3533.                               outputRectangle(singleRectangle,
  3534.                                RECTANGLE_W_E_COLOR);
  3535.                             }
  3536.                           for (vertexNum=0; vertexNum < 4; ++vertexNum)
  3537.                             ++rectangle[1][vertexNum].x;
  3538.                           ++x;
  3539.                         }
  3540.                     }
  3541.                   ++y;
  3542.                   if (y <= maxY)
  3543.                     {
  3544.                       for (vertexNum=0; vertexNum < 4; ++vertexNum)
  3545.                         {
  3546.                           rectangle[3][vertexNum].x=baseRectangle[3][vertexNum].x;
  3547.                           rectangle[3][vertexNum].y
  3548.                            =baseRectangle[3][vertexNum].y+yOffset;
  3549.                         }
  3550.                       x=0;
  3551.                       while (x <= maxX)
  3552.                         {
  3553.                           if (computerPage[y][x] == '\000')
  3554.                             {
  3555.                               singleRectangle[0].x=rectangle[3][0].x;
  3556.                               singleRectangle[0].y=rectangle[3][0].y;
  3557.                               singleRectangle[1].x=rectangle[3][1].x;
  3558.                               singleRectangle[1].y=rectangle[3][1].y;
  3559.                               singleRectangle[2].x=rectangle[3][2].x;
  3560.                               singleRectangle[2].y=rectangle[3][2].y;
  3561.                               singleRectangle[3].x=rectangle[3][3].x;
  3562.                               singleRectangle[3].y=rectangle[3][3].y;
  3563.                               outputLeftRight(singleRectangle);
  3564.                             }
  3565.                           for (vertexNum=0; vertexNum < 4; ++vertexNum)
  3566.                             ++rectangle[3][vertexNum].x;
  3567.                           x+=2;
  3568.                         }
  3569.                       for (vertexNum=0; vertexNum < 4; ++vertexNum)
  3570.                         {
  3571.                           rectangle[3][vertexNum].x=baseRectangle[3][vertexNum].x;
  3572.                           rectangle[3][vertexNum].y
  3573.                            =baseRectangle[3][vertexNum].y+yOffset;
  3574.                         }
  3575.                       x=0;
  3576.                       while (x <= maxX)
  3577.                         {
  3578.                           if (computerPage[y][x] == '\000')
  3579.                             {
  3580.                               singleRectangle[0].x=rectangle[3][0].x;
  3581.                               singleRectangle[0].y=rectangle[3][0].y;
  3582.                               singleRectangle[1].x=rectangle[3][1].x;
  3583.                               singleRectangle[1].y=rectangle[3][1].y;
  3584.                               singleRectangle[2].x=rectangle[3][2].x;
  3585.                               singleRectangle[2].y=rectangle[3][2].y;
  3586.                               singleRectangle[3].x=rectangle[3][3].x;
  3587.                               singleRectangle[3].y=rectangle[3][3].y;
  3588.                               outputRectangle(singleRectangle,
  3589.                                RECTANGLE_W_E_COLOR);
  3590.                             }
  3591.                           for (vertexNum=0; vertexNum < 4; ++vertexNum)
  3592.                             ++rectangle[3][vertexNum].x;
  3593.                           x+=2;
  3594.                         }
  3595.                       ++y;
  3596.                     }
  3597.                   ++yOffset;
  3598.                 }
  3599.               else
  3600.                 state=5;
  3601.               if (state == 5)
  3602.                 {
  3603.                   alreadyPainting=false;
  3604.                   sqrDisplayUserMoves();
  3605.                   if (solutionDisplayed)
  3606.                     sqrDisplaySolution();
  3607.                 }
  3608.               break;
  3609.             default:
  3610.               break;
  3611.           }
  3612.         return;
  3613.       }
  3614.   
  3615.     public void run()
  3616.       {
  3617.         do
  3618.           {
  3619.             if (state < 5)
  3620.               {
  3621.                 if (hexagonalRooms)
  3622.                   hexOutputMaze();
  3623.                 else
  3624.                   sqrOutputMaze();
  3625.               }
  3626.             yield();
  3627.             if (restart)
  3628.               {
  3629.                 restart=false;
  3630.                 graph=mazeCanvas.getGraphics().create();
  3631.                 screen=new Rectangle(mazeCanvas.rectangle.x,
  3632.                  mazeCanvas.rectangle.y,mazeCanvas.rectangle.width,
  3633.                  mazeCanvas.rectangle.height);
  3634.                 resize=mazeCanvas.resize;
  3635.                 if (resize)
  3636.                   userHasSolved=false;
  3637.                 hexagonalRooms=mazeCanvas.maze3D.hexagonalRooms;
  3638.                 solutionDisplayed=mazeCanvas.maze3D.solutionDisplayed;
  3639.                 if (mazeCanvas.maze3D.clearUserAttempts)
  3640.                   {
  3641.                     clearUserAttempts=true;
  3642.                     mazeCanvas.maze3D.clearUserAttempts=false;
  3643.                     userHasSolved=false;
  3644.                   }
  3645.                 tilt=mazeCanvas.maze3D.tilt;
  3646.                 paint=true;
  3647.                 alreadyPainting=true;
  3648.                 state=0;
  3649.               }
  3650.           }
  3651.         while (state < 6);       
  3652.       }
  3653.   }
  3654.