乌龟图形方向不起作用(Java)



我想编写一个执行以下命令的乌龟图形程序:

1:笔向上

2:笔下

3:右转

4:左转

5,10:向前移动10个空间(替换10个空间数量(

6:显示20乘20阵列

9:数据结束(Sentinel(

我写了两个班,但是看起来像我给它命令3以右转时,它不会!!!您能看一下它,告诉我可能是什么问题吗?谢谢

1st类:

import java.util.Arrays;
public class TurtleGraphics
{
   private enum Pen{PEN_UP,PEN_DOWN};
   private enum Turn{TURN_RIGHT,TURN_LEFT};
   private enum Direction{UP,DOWN,RIGHT,LEFT};
   private int [][] floor;
   private int [] currentPosition;
   private Direction direction;
   private Pen pen;
   public TurtleGraphics(Direction startDirection)
   {
          floor = new int [20][20];
          currentPosition = new int [2];
          pen = Pen.PEN_UP;
          direction = startDirection;
   }
   public TurtleGraphics(int [] initialPosition)    // removed paramater direction because i did not know how to pass it from class test
   {
          floor = new int [20][20];
          currentPosition = new int [2];
          currentPosition = initialPosition;
          pen = Pen.PEN_UP;
          this.direction = Direction.RIGHT;
   }
   public void turtle(String [] command)
   {
          int count = 0;
          while(count < command.length)
          {
                  char firstLetter = command[count].charAt(0);
                  int commandCode = Character.getNumericValue(firstLetter);
                 switch (commandCode)
                 {
                        case 1:
                        pen = Pen.PEN_UP;
                        break;
                        case 2:
                        pen = Pen.PEN_DOWN;
                        break;
                        case 3:
                        turn(Turn.TURN_RIGHT);
                       // System.out.println(direction);
                        break;
                        case 4:
                        turn(Turn.TURN_LEFT);
                       // System.out.println(direction);
                        break;
                        case 5:
                        String stepString = String.format ("%c%c",command[count].charAt(2),command[count].charAt(3));
                        int stepsCount = Integer.parseInt(stepString);
                        moveForward(stepsCount);
                      //  System.out.printf("%d,%d%n",currentPosition[0],currentPosition[1]);
                        break;
                        case 6:
                        display();
                        case 9:
                        count = command.length;
                        break;
                 }
                 count++;
          }
   }
   public void pen(int row , int column)
   {
         switch (pen)
         {
                case PEN_UP: // pen up : do nothing
                break;
                case PEN_DOWN:   // pen down : set appropiate floor elements to 1s.
                floor[row][column] = 1;
                break;
         }
   }
   public void turn(Turn turn)
   {
         switch (turn)
         {
                case TURN_RIGHT:
                switch (direction)
                {
                       case UP:
                       this.direction = Direction.RIGHT;
                       break;
                       case DOWN:
                       this.direction = Direction.LEFT;
                       break;
                       case RIGHT:
                       this.direction = Direction.DOWN;
                       break;
                       case LEFT:
                       this.direction = Direction.UP;
                       break;
                }
                case TURN_LEFT:
                switch (direction)
                {
                       case UP:
                       this.direction = Direction.LEFT;
                       break;
                       case DOWN:
                       this.direction = Direction.RIGHT;
                       break;
                       case RIGHT:
                       this.direction = Direction.UP;
                       break;
                       case LEFT:
                       this.direction = Direction.DOWN;
                       break;
                }
         }
   }
   public void moveForward(int spaces)
   {
                 switch (direction)
                 {
                        case UP:
                        if ( currentPosition[0] - spaces >= 0 )
                        {
                             for (int i = 1; i<= spaces ; i++)
                             {
                                 pen(currentPosition[0] - i , currentPosition[1]);
                             }
                             currentPosition[0] -= spaces;
                        }
                        else
                        {
                            System.out.printf("Turtle can not move further in %s direction%n",direction);
                        }
                        break;
                        case DOWN:
                        if ( currentPosition[0] + spaces < floor.length )
                        {
                             for (int i = 1; i<= spaces ; i++)
                             {
                                 pen(currentPosition[0] + i , currentPosition[1]);
                             }
                             currentPosition[0] += spaces;
                        }
                        else
                        {
                            System.out.printf("Turtle can not move further in %s direction%n",direction);
                        }
                        break;
                        case LEFT:
                        if ( currentPosition[1] - spaces >= 0 )
                        {
                             for (int i = 1; i<= spaces ; i++)
                             {
                                 pen(currentPosition[0] , currentPosition[1] - i);
                             }
                             currentPosition[1] -= spaces;
                        }
                        else
                        {
                            System.out.printf("Turtle can not move further in %s direction%n",direction);
                        }
                        break;
                        case RIGHT:
                        if ( currentPosition[1] + spaces < floor[0].length )
                        {
                             for (int i = 1; i<= spaces ; i++)
                             {
                                 pen(currentPosition[0] , currentPosition[1] + i);
                             }
                             currentPosition[1] += spaces;
                        }
                        else
                        {
                            System.out.printf("Turtle can not move further in %s direction%n",direction);
                        }
                 }
   }
   public void display()
   {
          System.out.println();
          for (int row = 0 ; row < floor.length ; row++)
          {
                   for (int column = 0 ; column < floor[row].length ; column++)
                   {
                            if (floor[row][column] == 1)
                            System.out.print("*");
                            else
                            System.out.print(" ");
                   }
                   System.out.println();
          }
   }
}

第二类:

public class TurtleGraphicsTest
{
   public static void main (String [] args)
   {
          int [] initialPosition = {3,3};
          TurtleGraphics turtle = new TurtleGraphics(initialPosition);
          String [] command = {"2","5,12","3","5,12","3","5,12","3","5,12","1","6","9"} ;
          turtle.turtle(command);
   }
}

您在turn(Turn)中的case语句中错过了break。因此,右转后,您也进入case TURN_LEFT,并且有了原始的方向。

您的方法应该看起来像

public void turn(Turn turn) {
    switch (turn) {
        case TURN_RIGHT:
            switch (direction) {
                case UP:
                    this.direction = Direction.RIGHT;
                    break;
                case DOWN:
                    this.direction = Direction.LEFT;
                    break;
                case RIGHT:
                    this.direction = Direction.DOWN;
                    break;
                case LEFT:
                    this.direction = Direction.UP;
                    break;
            }
            break; // necessary
        case TURN_LEFT:
            switch (direction) {
                case UP:
                    this.direction = Direction.LEFT;
                    break;
                case DOWN:
                    this.direction = Direction.RIGHT;
                    break;
                case RIGHT:
                    this.direction = Direction.UP;
                    break;
                case LEFT:
                    this.direction = Direction.DOWN;
                    break;
            }
            break; // optional
    }
}

最新更新