maze3d.java

Java编写的求解迷宫问题的小程序

      double    y,
      double    z)
        {
          POINT  corner;
          double xAdjusted;
          double yPrime;
          double zAdjusted;
          double zPrime;

          yPrime=(yMax-y)*cosTilt-z*sinTilt;
          zPrime=(yMax-y)*sinTilt+z*cosTilt;
          zAdjusted=(yMax/2)+relDistOfUserFromScreen
           *(zPrime-(yMax/2))/(yPrime+relDistOfUserFromScreen);
          xAdjusted=(xMax/2)+relDistOfUserFromScreen
           *(x-(xMax/2))/(yPrime+relDistOfUserFromScreen);
          xAdjusted=xAdjusted+xOffset;
          corner=new POINT();
          corner.x=(int) (pixelsPerX*xAdjusted);
          corner.y=screen.height-(int) (pixelsPerZ*zAdjusted);
          return corner;
        }

    private void displayQuadrilateral(
      double x0,
      double y0,
      double z0,
      double x1,
      double y1,
      double z1,
      double x2,
      double y2,
      double z2,
      double x3,
      double y3,
      double z3,
      int    shade)
        {
          int   i;
          POINT quadrilateral [];

          quadrilateral=new POINT [4];
          quadrilateral[0]=getCorner(x0,y0,z0);
          quadrilateral[1]=getCorner(x1,y1,z1);
          quadrilateral[2]=getCorner(x2,y2,z2);
          quadrilateral[3]=getCorner(x3,y3,z3);
          drawQuadrilateral(quadrilateral,shade);
          return;
        }

    private void drawTriangle(
      POINT box [],
      int   colorNum)
        {
          int i;
          int x [];
          int y [];

          x=new int [3];
          y=new int [3];
          for (i=0; i < 3; ++i)
            {
              x[i]=box[i].x;
              y[i]=box[i].y;
            }
          graph.setColor(redGreenBlue[colorNum]);
          graph.fillPolygon(x,y,3);
          return;
        }

    private void displayTriangle(
      double x0,
      double y0,
      double z0,
      double x1,
      double y1,
      double z1,
      double x2,
      double y2,
      double z2,
      int    shade)
        {
          int   i;
          POINT triangle [];

          triangle=new POINT [3];
          triangle[0]=getCorner(x0,y0,z0);
          triangle[1]=getCorner(x1,y1,z1);
          triangle[2]=getCorner(x2,y2,z2);
          drawTriangle(triangle,shade);
          return;
        }

    private void outputTriangle(
      VertexRec triangle [],
      boolean   firstPass,
      int       faceColor)
        {
          double x0;
          double x1;
          double x2;
          double x3;
          double y0;
          double y1;
          double y2;
          double y3;

          if (firstPass)
            {
              if ((triangle[1].x < xMax/2.0) && (triangle[1].x > triangle[0].x))
                {
                  x0=triangle[2].x;
                  y0=triangle[2].y;
                  x1=triangle[1].x;
                  y1=triangle[1].y;
                  x2=triangle[1].x;
                  y2=triangle[1].y;
                  x3=triangle[2].x;
                  y3=triangle[2].y;
                  displayQuadrilateral(x0,y0,RELATIVE_HEIGHT_OF_WALL,x1,y1,
                   RELATIVE_HEIGHT_OF_WALL,x2,y2,0.0,x3,y3,0.0,
                   TRIANGLE_SSW_NNE_COLOR);
                }
              if ((triangle[1].x > xMax/2.0) && (triangle[1].x < triangle[2].x))
                {
                  x0=triangle[1].x;
                  y0=triangle[1].y;
                  x1=triangle[0].x;
                  y1=triangle[0].y;
                  x2=triangle[0].x;
                  y2=triangle[0].y;
                  x3=triangle[1].x;
                  y3=triangle[1].y;
                  displayQuadrilateral(x0,y0,RELATIVE_HEIGHT_OF_WALL,x1,y1,
                   RELATIVE_HEIGHT_OF_WALL,x2,y2,0.0,x3,y3,0.0,
                   TRIANGLE_SSE_NNW_COLOR);
                }
            }
          else
            {
              x0=triangle[0].x;
              y0=triangle[0].y;
              x1=triangle[2].x;
              y1=triangle[2].y;
              x2=triangle[2].x;
              y2=triangle[2].y;
              x3=triangle[0].x;
              y3=triangle[0].y;
              displayQuadrilateral(x0,y0,RELATIVE_HEIGHT_OF_WALL,
               x1,y1,RELATIVE_HEIGHT_OF_WALL,x2,y2,0.0,x3,y3,0.0,faceColor);
              x0=triangle[0].x;
              y0=triangle[0].y;
              x1=triangle[1].x;
              y1=triangle[1].y;
              x2=triangle[2].x;
              y2=triangle[2].y;
              displayTriangle(x0,y0,RELATIVE_HEIGHT_OF_WALL,
               x1,y1,RELATIVE_HEIGHT_OF_WALL,x2,y2,RELATIVE_HEIGHT_OF_WALL,
               TOP_COLOR);
            }
          return;
        }

    private void outputRectangle(
      VertexRec rectangle [],
      int       faceColor)
        {
          double x0;
          double x1;
          double x2;
          double x3;
          double y0;
          double y1;
          double y2;
          double y3;

          x0=rectangle[3].x;
          y0=rectangle[3].y;
          x1=rectangle[2].x;
          y1=rectangle[2].y;
          x2=rectangle[2].x;
          y2=rectangle[2].y;
          x3=rectangle[3].x;
          y3=rectangle[3].y;
          displayQuadrilateral(x0,y0,RELATIVE_HEIGHT_OF_WALL,x1,
           y1,RELATIVE_HEIGHT_OF_WALL,x2,y2,0.0,x3,y3,0.0,faceColor);
          x0=rectangle[0].x;
          y0=rectangle[0].y;
          x1=rectangle[1].x;
          y1=rectangle[1].y;
          x2=rectangle[2].x;
          y2=rectangle[2].y;
          x3=rectangle[3].x;
          y3=rectangle[3].y;
          displayQuadrilateral(x0,y0,RELATIVE_HEIGHT_OF_WALL,x1,
           y1,RELATIVE_HEIGHT_OF_WALL,x2,y2,RELATIVE_HEIGHT_OF_WALL,x3,y3,
           RELATIVE_HEIGHT_OF_WALL,TOP_COLOR);
          return;
        }

    private void outputLeftRight(
      VertexRec rectangle [])
        {
          double x0;
          double x1;
          double x2;
          double x3;
          double y0;
          double y1;
          double y2;
          double y3;

          if (2.0*rectangle[0].x > xMax)
            {
              x0=rectangle[0].x;
              y0=rectangle[0].y;
              x1=rectangle[3].x;
              y1=rectangle[3].y;
              x2=rectangle[3].x;
              y2=rectangle[3].y;
              x3=rectangle[0].x;
              y3=rectangle[0].y;
              displayQuadrilateral(x0,y0,RELATIVE_HEIGHT_OF_WALL,x1,y1,
               RELATIVE_HEIGHT_OF_WALL,x2,y2,0.0,x3,y3,0.0,
               RECTANGLE_SE_NW_COLOR);
            }
          if (2.0*rectangle[1].x < xMax)
            {
              x0=rectangle[2].x;
              y0=rectangle[2].y;
              x1=rectangle[1].x;
              y1=rectangle[1].y;
              x2=rectangle[1].x;
              y2=rectangle[1].y;
              x3=rectangle[2].x;
              y3=rectangle[2].y;
              displayQuadrilateral(x0,y0,RELATIVE_HEIGHT_OF_WALL,x1,y1,
               RELATIVE_HEIGHT_OF_WALL,x2,y2,0.0,x3,y3,0.0,
               RECTANGLE_SW_NE_COLOR);
            }
          return;
        }

    private void drawLine(
      double x1,
      double y1,
      double x2,
      double y2)
        {
          int   lineX1;
          int   lineX2;
          int   lineY1;
          int   lineY2;
          POINT tem;

          tem=getCorner(x1,y1,RELATIVE_HEIGHT_OF_WALL);
          lineX1=tem.x;
          lineY1=tem.y;
          tem=getCorner(x2,y2,RELATIVE_HEIGHT_OF_WALL);
          lineX2=tem.x;
          lineY2=tem.y;
          graph.drawLine(lineX1,lineY1,lineX2,lineY2);
          return;
        }

    private void hash()
      {
        int iteration;
        int seed0;
        int seed1;
        int seed2;
        int seed3;
        int seed4;
        int seed5;
        int seed6;
        int seed7;
        int substitutionIndex;
        int tem0;
        int tem1;
        int tem2;

        seed0=counter0;
        seed1=counter1;
        seed2=counter2;
        seed3=counter3;
        seed4=counter4;
        seed5=counter5;
        seed6=counter6;
        seed7=counter7;
        for (iteration=8; iteration > 0; --iteration)
          {
            substitutionIndex=10*seed1+seed0;
            tem0=SUBSTITUTION_LOW[substitutionIndex];
            tem1=SUBSTITUTION_HIGH[substitutionIndex];
            substitutionIndex=10*seed3+seed2;
            seed0=SUBSTITUTION_LOW[substitutionIndex];
            tem2=SUBSTITUTION_HIGH[substitutionIndex];
            substitutionIndex=10*seed5+seed4;
            seed2=SUBSTITUTION_LOW[substitutionIndex];
            seed1=SUBSTITUTION_HIGH[substitutionIndex];
            substitutionIndex=10*seed7+seed6;
            seed5=SUBSTITUTION_LOW[substitutionIndex];
            seed7=SUBSTITUTION_HIGH[substitutionIndex];
            seed3=tem0;
            seed6=tem1;
            seed4=tem2;
          }
        counter0=seed0;
        counter1=seed1;
        counter2=seed2;
        counter3=seed3;
        counter4=seed4;
        counter5=seed5;
        counter6=seed6;
        counter7=seed7;
        return;
      }

    private void increment()
      {
        int tem;

        tem=(counter0)+1;
        if (tem <= 9)
          counter0=tem;
        else
          {
            counter0=0;
            tem=(counter1)+1;
            if (tem <= 9)
              counter1=tem;
            else
              {
                counter1=0;
                tem=(counter2)+1;
                if (tem <= 9)
                  counter2=tem;
                else
                  {
                    counter2=0;
                    tem=(counter3)+1;
                    if (tem <= 9)
                      counter3=tem;
                    else
                      {
                        counter3=0;
                        tem=(counter4)+1;
                        if (tem <= 9)
                          counter4=tem;
                        else
                          {
                            counter4=0;
                            tem=(counter5)+1;
                            if (tem <= 9)
                              counter5=tem;
                            else
                              {
                                counter5=0;
                                tem=(counter6)+1;
                                if (tem <= 9)
                                  counter6=tem;
                                else
                                  {