'Rückgängig Move' Feature-Implementierung für ein 2D-Array-Brettspiel

Question

'Rückgängig Move' Feature-Implementierung für ein 2D-Array-Brettspiel

Hallo alle

eine Arraylist verwenden, Ich versuche, eine Undo-Bewegung Funktion zu implementieren wobei ein Benutzer eine Option 'Z' auswählen kann, die ein mehrstufiges 'Rückgängigmachen' ermöglicht. Mit anderen Worten, wenn der Benutzer 'Z' auswählt, wird der vorherige Zug rückgängig gemacht, wenn er sofort wieder 'Z' auswählt, der vorherige Zug rückgängig gemacht wird, und so weiter.

Ich konnte den Code bekommen, um jedes Mal, wenn ein gültiger Zug 'U', 'D', 'L', 'R' gemacht wird, neue Bewegungsobjekte hinzuzufügen und auch das letzte Objekt jedes Mal zu entfernen ' Z 'wird gedrückt.

Meine Frage ist, wie mache ich die Spieler Bewegungen (Koordinaten) und gegessen Donuts (Boolean) verlassen auf das letzte Objekt in der ArrayList, so dass, wenn Z gedrückt und das letzte Objekt in der ArrayList entfernt wird, Die Spielerbewegungen und gegessenen Donuts verlassen sich nun auf das neue letzte Objekt in der ArrayList, um den "Rückgängig" -Effekt zu erzeugen. Hoffe meine Frage ergibt Sinn.

Die 'Z'-Implementierung ist der letzte Fall in der switch-Anweisung in der move-Methode.

sind meine Klassen unter:

package secondproject; 

import java.util.ArrayList; 
import java.util.Random; 
import java.util.Scanner; 

public class Game { 

    private static final int BOARD_SIZE = 10; 
    private static final int INITIAL_PLAYER_COL = 0; 
    private static final int INITIAL_PLAYER_ROW = BOARD_SIZE - 1; 
    private static final int HOME_COL = BOARD_SIZE - 1; 
    private static final int HOME_ROW = 0; 
    private static final int WALL_LENGTH = 5; 
    private static final char PLAYER_CHAR = 'P'; 
    private static final char HOME_CHAR = 'H'; 
    private static final char WALL_CHAR = 'X'; 
    private static final char FREE_SQUARE_CHAR = '.'; 
    private static final char DOUGHNUT_CHAR = '@'; 
    private static final char UP_MOVE_CHAR = 'U'; 
    private static final char DOWN_MOVE_CHAR = 'D'; 
    private static final char LEFT_MOVE_CHAR = 'L'; 
    private static final char RIGHT_MOVE_CHAR = 'R'; 
    private static final char UNDO_MOVE_CHAR = 'Z'; 
    private static final char TRAIL_CHAR = 'M'; 

    private static char[][] board = new char[BOARD_SIZE][BOARD_SIZE]; 
    private static Scanner scan = new Scanner(System.in); 
    private static Scanner keyBoard = new Scanner(System.in); 

    private static int playerCol = INITIAL_PLAYER_COL; 
    private static int playerRow = INITIAL_PLAYER_ROW; 
    private static int nbrDoughnuts = 0; 
    private static int nbrMoves = 0; 
    private static Random random = new Random(); 

    private static int lives = 1; 
    private static int doughnutLives; 
    private static boolean doughnutCheck; 
    static ArrayList<Move> movement = new ArrayList<Move>(); 

    public static void main(String[] args) { 

     setUpBoard(); 
     showBoard(); 
     String opt; 
     do { 
      System.out.print("Next option ?"); 
      opt = scan.next(); 
      char opt1 = opt.charAt(0); 
      if (opt1 == UP_MOVE_CHAR || opt1 == DOWN_MOVE_CHAR || opt1 == LEFT_MOVE_CHAR || opt1 == RIGHT_MOVE_CHAR || opt1 == UNDO_MOVE_CHAR) { 
       move(opt1); 
      } else { 
       System.out.println("Allowed commands are: + " + UP_MOVE_CHAR + "," + DOWN_MOVE_CHAR + "," + LEFT_MOVE_CHAR + "," + RIGHT_MOVE_CHAR); 
      } 
      showBoard(); 
      System.out.println("Number of moves made = " + nbrMoves); 
      System.out.println("Number of doughnuts eaten = " + nbrDoughnuts); 
      System.out.println("Lives = " + lives); 
     } while (board[HOME_ROW][HOME_COL] == HOME_CHAR); 
     System.out.println("Thank you and goodbye"); 
    } 

    /** 
    * Set up the initial state of the board 
    */ 
    private static void setUpBoard() { 
     intialiseBoard(); // Fill the board with . characters 
     //Add the first vertical wall 
     int v1StartCol = 1 + random.nextInt(BOARD_SIZE - 2); 
     int v1StartRow = 1 + random.nextInt(BOARD_SIZE - WALL_LENGTH - 1); 
     addVerticalWall(v1StartCol, v1StartRow, WALL_LENGTH); 

     //Add the second vertical wall 
     int v2StartCol; 
     do { 
      v2StartCol = 1 + random.nextInt(BOARD_SIZE - 2); 
     } while (v2StartCol == v1StartCol); 
     int v2StartRow = 1 + random.nextInt(BOARD_SIZE - WALL_LENGTH - 1); 
     addVerticalWall(v2StartCol, v2StartRow, WALL_LENGTH); 

     //Add the horizontal wall 
     int h1StartRow = 1 + random.nextInt(BOARD_SIZE - 2); 
     int h1StartCol = 1 + random.nextInt(BOARD_SIZE - WALL_LENGTH - 1); 
     addHorizontalWall(h1StartCol, h1StartRow, WALL_LENGTH); 

     //Add the dougnuts 
     int nbrDoughnutsAdded = 0; 
     while (nbrDoughnutsAdded < 5) { 
      int dRow = 1 + random.nextInt(BOARD_SIZE - 2); 
      int dCol = 1 + random.nextInt(BOARD_SIZE - 2); 
      if (board[dRow][dCol] == FREE_SQUARE_CHAR) { 
       board[dRow][dCol] = DOUGHNUT_CHAR; 
       nbrDoughnutsAdded++; 
      } 
     } 

     //Add the player and the home square 
     board[playerRow][playerCol] = PLAYER_CHAR; 
     board[HOME_ROW][HOME_COL] = HOME_CHAR; 
    } 

    /** 
    * Add a vertical wall to the board 
    * 
    * @param startCol Column on which wall is situated 
    * @param startRow Row on which top of wall is situated 
    * @param length Number of squares occupied by wall 
    */ 
    private static void addVerticalWall(int startCol, int startRow, int length) { 
     for (int row = startRow; row < startRow + length; row++) { 
      board[row][startCol] = WALL_CHAR; 
     } 
    } 

    /** 
    * Add a horizontal wall to the board 
    * 
    * @param startCol Column on which leftmost end of wall is situated 
    * @param startRow Row on which wall is situated 
    * @param length Number of squares occupied by wall 
    */ 
    private static void addHorizontalWall(int startCol, int startRow, int length) { 
     for (int col = startCol; col < startCol + length; col++) { 
      board[startRow][col] = WALL_CHAR; 
     } 
    } 

    /** 
    * Display the board 
    */ 
    private static void showBoard() { 
     for (int row = 0; row < board.length; row++) { 
      for (int col = 0; col < board[row].length; col++) { 
       System.out.print(board[row][col]); 
      } 
      System.out.println(); 
     } 
    } 

    /** 
    * Fill the board with FREE_SQUARE_CHAR characters. 
    */ 
    private static void intialiseBoard() { 
     for (int row = 0; row < board.length; row++) { 
      for (int col = 0; col < board[row].length; col++) { 
       board[row][col] = FREE_SQUARE_CHAR; 
      } 
      System.out.println(); 
     } 
    } 

    /** 
    * Move the player 
    * 
    * @param moveChar Character indicating the move to be made 
    */ 
    private static void move(char moveChar) { 
     int newCol = playerCol; 
     int newRow = playerRow; 

     switch (moveChar) { 
      case UP_MOVE_CHAR: 
       if (lives == 1) { 
        newRow--; 
       } else if (lives > 1) { 
        int number = keyBoard.nextInt(); 
        if (number <= lives) { 
         newRow = newRow - number; 
        } else { 
         checkLives(); 
        } 
       } 
       break; 
      case DOWN_MOVE_CHAR: 
       if (lives == 1) { 
        newRow++; 
       } else if (lives > 1) { 
        squareNumberPrompt(); 
        int number = keyBoard.nextInt(); 
        if (number <= lives) { 
         newRow = newRow + number; 
        } else { 
         checkLives(); 
        } 
       } 
       break; 
      case LEFT_MOVE_CHAR: 
       if (lives == 1) { 
        newCol--; 
       } else if (lives > 1) { 
        squareNumberPrompt(); 
        int number = keyBoard.nextInt(); 
        if (number <= lives) { 
         newCol = newCol - number; 
        } else { 
         checkLives(); 
        } 
       } 
       break; 
      case RIGHT_MOVE_CHAR: 
       if (lives == 1) { 
        newCol++; 
       } else if (lives > 1) { 
        squareNumberPrompt(); 
        int number = keyBoard.nextInt(); 
        if (number <= lives) { 
         newCol = newCol + number; 
        } else { 
         checkLives(); 
        } 
       } 
       break; 
      case UNDO_MOVE_CHAR: 
       if (movement.size() >= 1) { 
        movement.remove(movement.size() - 1); 
        System.out.println("The decreasing size of the arraylist is now " + movement.size()); 
       } else if (movement.size() < 1) { 
        System.out.println("There is no move to be undone!"); 
       } 
       break; 
     } 
     if (newRow < 0 || newRow >= BOARD_SIZE || newCol < 0 || newCol >= BOARD_SIZE) { 
      System.out.println("Sorry that move takes you off the board!"); 
     } else { 
      char dest = board[newRow][newCol]; 
      if (dest == WALL_CHAR) { 
       System.out.println("Sorry you landed on a wall!"); 
      } else { 
       nbrMoves++; 
       if (dest == DOUGHNUT_CHAR) { 
        doughnutCheck = true; 
        nbrDoughnuts++; 
        doughnutLives++; 
        lives = (doughnutLives + 1); 
       } 
       board[playerRow][playerCol] = FREE_SQUARE_CHAR; 
       playerCol = newCol; 
       playerRow = newRow; 
       board[playerRow][playerCol] = PLAYER_CHAR; 
      } 
     } 
     if (moveChar == UP_MOVE_CHAR || moveChar == DOWN_MOVE_CHAR || moveChar == LEFT_MOVE_CHAR || moveChar == RIGHT_MOVE_CHAR) { 
      movement.add(new Move(playerCol, playerRow, newCol, newRow, doughnutCheck)); 
      System.out.println("The increasing size of the arraylist is now " + movement.size()); 
     } 
    } 

    public static void squareNumberPrompt() { 
     System.out.println("Enter the number of squares to be moved"); 
    } 

    public static void checkLives() { 
     System.out.println("Invalid number! The number must be" 
       + " equal to or less than the number of lives you have"); 
    } 
} 





package secondproject; 

import java.util.ArrayList; 

public class Move { 

    private static int pColumn; 
    private static int pRow; 
    private static int nCol; 
    private static int nRow; 
    private static boolean dCheck; 

    public Move(int playerCol, int playerRow, int newCol, int newRow, boolean doughnutCheck) { 
     pColumn = playerCol; 
     pRow = playerRow; 
     nCol = newCol; 
     nRow = newRow; 
     dCheck = doughnutCheck; 
    } 

    public int getFromCol() { 
     return pColumn; 
    } 

    public int getFromRow() { 
     return pRow; 
    } 

    public int getToCol() { 
     return nCol; 
    } 

    public int getToRow() { 
     return nRow; 
    } 

    public boolean isDoughnutEaten() { 
     return dCheck; 
    } 
} 

Answer 1

Nach etwas näher an Ihrem Code suchen, sind Sie im Grunde schon alles, was man für das an Ort und Stelle rückgängig gemacht werden müssen haben. Vielleicht sogar ein bisschen zu viel: D Sie brauchen eigentlich nicht von und zu Positionen. nur die Position, in der du dich bewegtest, würde ausreichen. So

, wenn Sie Z drücken, sollte Ihr Code aussehen etwas wie folgt aus:

Move lastMove = movement.remove(movement.size() - 1); 
playerCol = movement.get(movement.size() - 1).getToCol(); 
playerRow = movement.get(movement.size() - 1).getToRow(); 
board[playerRow][playerCol] = PLAYER_CHAR; 
if (lastMove.isDoughnutEaten()) { 
    int dCol = lastMove.getToCol(); 
    int dRow = lastMove.getToRow(); 
    board[dRow][dCol] = DOUGHNUT_CHAR; 
    nbrDoughnutsAdded--; 
} 

Gerade jetzt, können Sie die neue Spielerposition aus den pColumn und pRow Werte von lastMove lesen konnte, aber wie gesagt, das ist Art von Overkill, weil Sie es sowieso aus dem neuen letzten Element der Liste lesen können.

Denken Sie daran, dass Sie immer noch spezielle Fälle fangen müssen (z. B. wenn Sie den ersten Zug rückgängig machen. In diesem Fall müssten Sie die ehemalige Spielerposition von Ihren statischen Variablen lesen, die den Startpunkt definieren das letzte Element der Liste (das wird nicht mehr existieren))