maze3d.java

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

                                    counter6=0;
                                    tem=(counter7)+1;
                                    if (tem <= 9)
                                      counter7=tem;
                                    else
                                      counter7=0;
                                  }
                              }
                          }
                      }
                  }
              }
          }
        return;
      }

    public void hexKey(
      int deltaIndex1)
        {
          boolean passageFound;
          int     xNext;
          double  xRelativeNext;
          int     yNext;
          double  yRelativeNext;

          yNext=0;
          xRelativeNext=0.0;
          yRelativeNext=0.0;
          passageFound=true;
          xNext=userX+hexDeltaX[deltaIndex1][0];
          if (xNext <= 0)
            passageFound=false;
          else
            if (xNext >= maxX)
              passageFound=false;
            else
              yNext=userY+hexDeltaY[deltaIndex1][0];
              if (yNext <= 0)
                passageFound=false;
              else
                if (yNext > maxY)
                  passageFound=false;
                else
                  {
                    if (userPage[yNext][xNext] == '\000')
                      passageFound=false;
                  }
          if (passageFound)
            {
              xNext=xNext+hexDeltaX[deltaIndex1][0];
              yNext=yNext+hexDeltaY[deltaIndex1][0];
              if (yNext < maxY)
                {
                  if (userPage[yNext][xNext] == '\001')
                    {
                      graph.setColor(redGreenBlue[BACKOUT_COLOR]);
                      userPage[userY][userX]='\003';
                    }
                  else
                    {
                      graph.setColor(redGreenBlue[ADVANCE_COLOR]);
                      userPage[yNext][xNext]='\001';
                    }
                  switch (yNext - userY)
                    {
                      case -4:
                        xRelativeNext=userXRelative;
                        yRelativeNext=userYRelative-sqrt3;
                        break;
                      case -2:
                        if (xNext > userX)
                          {
                            xRelativeNext=userXRelative+3.0/2.0;
                            yRelativeNext=userYRelative-sqrt3/2.0;
                          }
                        else
                          {
                            xRelativeNext=userXRelative-3.0/2.0;
                            yRelativeNext=userYRelative-sqrt3/2.0;
                          }
                        break;
                      case 2:
                        if (xNext > userX)
                          {
                            xRelativeNext=userXRelative+3.0/2.0;
                            yRelativeNext=userYRelative+sqrt3/2.0;
                          }
                        else
                          {
                            xRelativeNext=userXRelative-3.0/2.0;
                            yRelativeNext=userYRelative+sqrt3/2.0;
                          }
                        break;
                      default:
                        xRelativeNext=userXRelative;
                        yRelativeNext=userYRelative+sqrt3;
                        break;
                    }
                  drawLine(userXRelative,userYRelative,xRelativeNext,
                   yRelativeNext);
                }
              else
                {
                  graph.setColor(redGreenBlue[ADVANCE_COLOR]);
                  drawLine(userXRelative,userYRelative,userXRelative,yMax);
                  userHasSolved=true;
                }
              userX=xNext;
              userY=yNext;
              userXRelative=xRelativeNext;
              userYRelative=yRelativeNext;
            }
        }

    public void hexDisplayUserMoves()
      {
        int     deltaIndex;
        boolean evenRow;
        int     x;
        int     xNext;
        int     xNextNext;
        double  xRelative;
        double  xRelativeNext;
        int     y;
        int     yNext;
        int     yNextNext;
        double  yRelative;
        double  yRelativeNext;

        xRelative=0.0;
        y=2;
        yRelative=sqrt3/2.0;
        evenRow=false;
        while (y < maxY)
          {
            if (evenRow)
              {
                x=7;
                xRelative=2.5;
              }
            else
              {
                x=3;
                xRelative=1.0;
              }
            while (x < maxX)
              {
                if ((userPage[y][x] == '\001') || (userPage[y][x] == '\003'))
                  for (deltaIndex=0; deltaIndex < 6; ++deltaIndex)
                    {
                      xNext=x+hexDeltaX[deltaIndex][0];
                      yNext=y+hexDeltaY[deltaIndex][0];
                      if (userPage[yNext][xNext] != '\000')
                        {
                          if (yNext == 0)
                            {
                              graph.setColor(redGreenBlue[ADVANCE_COLOR]);
                              drawLine(1.0,0.0,xRelative,yRelative);
                            }
                          else
                            if (yNext == maxY)
                              {
                                if (userHasSolved)
                                  {
                                    graph.setColor(redGreenBlue[ADVANCE_COLOR]);
                                    yRelativeNext=yRelative+sqrt3/2.0;
                                    drawLine(xRelative,yRelative,xRelative,
                                     yRelativeNext);
                                  }
                              }
                            else
                              {
                                xNextNext=xNext+hexDeltaX[deltaIndex][0];
                                if (xNextNext > 0)
                                  {
                                    if (xNextNext < maxX)
                                      {
                                        yNextNext
                                         =yNext+hexDeltaY[deltaIndex][0];
                                        if (yNextNext > 0)
                                          {
                                            if (yNextNext < maxY)
                                              {
                                                if ((userPage[yNextNext][
                                                 xNextNext] == '\001')
                                                ||  (userPage[yNextNext][
                                                 xNextNext] == '\003'))
                                                  {
                                                    if (userPage[y][x]
                                                     == userPage[yNextNext][
                                                     xNextNext])
                                                      if (userPage[y][x]
                                                       == '\001')
                                                        graph.setColor(
                                                         redGreenBlue[
                                                         ADVANCE_COLOR]);
                                                      else
                                                        graph.setColor(
                                                         redGreenBlue[
                                                         BACKOUT_COLOR]);
                                                    else
                                                      graph.setColor(
                                                       redGreenBlue[
                                                       BACKOUT_COLOR]);
                                                    switch (yNext - y)
                                                      {
                                                        case -2:
                                                          xRelativeNext
                                                           =xRelative;
                                                          yRelativeNext
                                                           =yRelative
                                                           -sqrt3/2.0;
                                                          break;
                                                        case -1:
                                                          if (xNext > x)
                                                            {
                                                              xRelativeNext
                                                               =xRelative
                                                               +3.0/4.0;
                                                              yRelativeNext
                                                               =yRelative
                                                               -sqrt3/4.0;
                                                            }
                                                          else
                                                            {
                                                              xRelativeNext
                                                               =xRelative
                                                               -3.0/4.0;
                                                              yRelativeNext
                                                               =yRelative
                                                               -sqrt3/4.0;
                                                            }
                                                          break;
                                                        case 1:
                                                          if (xNext > x)
                                                            {
                                                              xRelativeNext
                                                               =xRelative
                                                               +3.0/4.0;
                                                              yRelativeNext
                                                               =yRelative
                                                               +sqrt3/4.0;
                                                            }
                                                          else
                                                            {
                                                              xRelativeNext
                                                               =xRelative
                                                               -3.0/4.0;
                                                              yRelativeNext
                                                               =yRelative
                                                               +sqrt3/4.0;
                                                            }
                                                          break;
                                                        default:
                                                          xRelativeNext
                                                           =xRelative;
                                                          yRelativeNext
                                                           =yRelative+sqrt3/2.0;
                                                          break;
                                                      }
                                                    drawLine(xRelative,
                                                     yRelative,xRelativeNext,
                                                     yRelativeNext);
                                                  }
                                               }
                                          }
                                      }
                                  }
                              }
                        }
                    }
                xRelative+=3.0;
                x+=8;
              }
            evenRow=! evenRow;
            yRelative+=sqrt3/2.0;
            y+=2;
          }
        if (userHasSolved)
          {
            graph.setColor(redGreenBlue[ADVANCE_COLOR]);
            drawLine(xRelative,yRelative,xRelative,yMax);
          }
      }

    private void hexSolveMaze()
        {
          int     deltaIndex;
          boolean passageFound;
          int     stackHead;
          int     x;
          int     xNext;
          int     y;
          int     yNext;

          numRoomsInSolution=1;
          adjacency=0;
          x=3;
          y=2;
          stackHead=-1;
          computerPage[y][x]='\001';
          yNext=0;
          xNext=0;
          do
            {
              deltaIndex=0;
              passageFound=false;
              do
                {
                  while ((deltaIndex < 6) && (! passageFound))
                    {
                      xNext=x+hexDeltaX[deltaIndex][0];
                      yNext=y+hexDeltaY[deltaIndex][0];
                      if (computerPage[yNext][xNext] == '\002')
                        passageFound=true;
                      else
                        ++deltaIndex;
                    }
                  if (! passageFound)
                    {
                      deltaIndex=stack[stackHead].index1;
                      computerPage[y][x]='\002';
                      x-=hexDeltaX[deltaIndex][0];
                      y-=hexDeltaY[deltaIndex][0];
                      computerPage[y][x]='\002';
                      x-=hexDeltaX[deltaIndex][0];
                      y-=hexDeltaY[deltaIndex][0];
                      --stackHead;
                      ++deltaIndex;
                    }
                }
              while (! passageFound);
              computerPage[yNext][xNext]='\001';
              xNext+=hexDeltaX[deltaIndex][0];
              yNext+=hexDeltaY[deltaIndex][0];
              if (yNext <= maxY)
                {
                  stack[++stackHead].index1=(short) deltaIndex;
                  computerPage[yNext][xNext]='\001';
                  x=xNext;
                  y=yNext;
                }
            }
          while (yNext < maxY);
          x=maxX-3;
          y=maxY-2;
          adjacency=0;
          while (stackHead >= 0)
            {
              for (deltaIndex=0; deltaIndex < 6; ++deltaIndex)
                {
                  xNext=x+hexDeltaX[deltaIndex][0];
                  yNext=y+hexDeltaY[deltaIndex][0];
                  if (computerPage[yNext][xNext] != '\001')
                    {
                      if (computerPage[yNext][xNext] == '\000')
                        {
                          xNext+=hexDeltaX[deltaIndex][0];
                          yNext+=hexDeltaY[deltaIndex][0];
                          if (xNext < 0)
                            ++adjacency;
                          else