459 lines
16 KiB
Java
459 lines
16 KiB
Java
import java.util.Scanner;
|
|
import java.io.File;
|
|
/**
|
|
* @author: ______your name here (SID)_________
|
|
*
|
|
* For the instruction of the assignment please refer to the assignment
|
|
* GitHub.
|
|
*
|
|
* Plagiarism is a serious offense and can be easily detected. Please
|
|
* don't share your code to your classmate even if they are threatening
|
|
* you with your friendship. If they don't have the ability to work on
|
|
* something that can compile, they would not be able to change your
|
|
* code to a state that we can't detect the act of plagiarism. For the
|
|
* first commit of plagiarism, regardless you shared your code or
|
|
* copied code from others, you will receive 0 with an addition of 5
|
|
* mark penalty. If you commit plagiarism twice, your case will be
|
|
* presented in the exam board and you will receive a F directly.
|
|
*
|
|
* Terms about generative AI:
|
|
* You are not allowed to use any generative AI in this assignment.
|
|
* The reason is straight forward. If you use generative AI, you are
|
|
* unable to practice your coding skills. We would like you to get
|
|
* familiar with the syntax and the logic of the Java programming.
|
|
* We will examine your code using detection software as well as
|
|
* inspecting your code with our eyes. Using generative AI tool
|
|
* may fail your assignment.
|
|
*
|
|
* If you cannot work out the logic of the assignment, simply contact
|
|
* us on Discord. The teaching team is more the eager to provide
|
|
* you help. We can extend your submission due if it is really
|
|
* necessary. Just please, don't give up.
|
|
*/
|
|
public class Sokoban {
|
|
/**
|
|
* The following constants are variables that you can use in your code.
|
|
* Use them whenever possible. Try to avoid writing something like:
|
|
* if (input == 'W') ...
|
|
* instead
|
|
* if (input == UP) ...
|
|
*/
|
|
public static final char UP = 'W';
|
|
public static final char DOWN = 'S';
|
|
public static final char LEFT = 'A';
|
|
public static final char RIGHT = 'D';
|
|
public static final char PLAYER = 'o';
|
|
public static final char BOX = '@';
|
|
public static final char WALL = '#';
|
|
public static final char GOAL = '.';
|
|
public static final char BOXONGOAL = '%';
|
|
|
|
/**
|
|
* Finished. You are not allowed to touch this method.
|
|
* The main method.
|
|
*/
|
|
public static void main(String[] args) {
|
|
new Sokoban().runApp();
|
|
}
|
|
/**
|
|
* All coding of this method has been finished.
|
|
* You are not supposed to add or change any code in this method.
|
|
* However, you are required to add comments after every // to explain the code below.
|
|
*/
|
|
public void runApp() {
|
|
|
|
String mapfile = "map1.txt"; //change this to test other maps
|
|
char[][] map = readmap(mapfile); //
|
|
char[][] oldMap = readmap(mapfile); //
|
|
|
|
if (map == null) { //
|
|
System.out.println("Map file not found");
|
|
return;
|
|
}
|
|
int[] start = findPlayer(map); //
|
|
if (start.length == 0) { //
|
|
System.out.println("Player not found");
|
|
return;
|
|
}
|
|
int row = start[0];
|
|
int col = start[1];
|
|
while (!gameOver(map)) { //
|
|
printMap(map);
|
|
System.out.println("\nPlease enter a move (WASD): ");
|
|
char input = readValidInput(); //
|
|
if (input == 'q') //
|
|
break;
|
|
if (input == 'r') { //
|
|
map = readmap(mapfile);
|
|
row = start[0]; //
|
|
col = start[1];
|
|
continue;
|
|
}
|
|
if (input == 'h') { //
|
|
printHelp();
|
|
}
|
|
if (!isValid(map, row, col, input)) //
|
|
continue;
|
|
movePlayer(map, row, col, input); //
|
|
|
|
// fixMap(map, oldMap); //
|
|
|
|
int[] newPos = findPlayer(map); //
|
|
row = newPos[0]; //
|
|
col = newPos[1];
|
|
|
|
}
|
|
System.out.println("Bye!");
|
|
}
|
|
|
|
/**
|
|
* Print the Help menu.
|
|
* TODO:
|
|
*
|
|
* Inspect the code in runApp() and find out the function of each characters.
|
|
* The first one has been done for you.
|
|
*/
|
|
public void printHelp() {
|
|
System.out.println("Sokoban Help:");
|
|
System.out.println("Move up: W");
|
|
System.out.println("Move down: S");
|
|
System.out.println("Move left: A");
|
|
System.out.println("Move right: D");
|
|
System.out.println("Restart level: r");
|
|
System.out.println("Quit game: q");
|
|
System.out.println("Help: h");
|
|
}
|
|
/**
|
|
* Reading a valid input from the user.
|
|
*
|
|
* TODO
|
|
*
|
|
* This method will return a character that the user has entered. However, if a user enter an invalid character (e.g. 'x'),
|
|
* the method should keep prompting the user until a valid character is entered. Noted, there are all together 7 valid characters
|
|
* which you need to figure out yourself.
|
|
*/
|
|
public char readValidInput() {
|
|
char c2;
|
|
Scanner scanner = new Scanner(System.in);
|
|
while (true) {
|
|
String string;
|
|
if ((string = scanner.nextLine()).length() == 0) {
|
|
continue;
|
|
}
|
|
c2 = string.charAt(0);
|
|
if (c2 == 'W' || c2 == 'S' || c2 == 'A' || c2 == 'D' || c2 == 'q' || c2 == 'r' || c2 == 'h') break;
|
|
System.out.println("Invalid input, please enter again: ");
|
|
}
|
|
return c2;
|
|
}
|
|
|
|
/**
|
|
* Mysterious method.
|
|
*
|
|
* TODO
|
|
*
|
|
* We know this method is to "fix" the map. But we don't know how it does and why it is needed.
|
|
* You need to figure out the function of this method and implement it accordingly.
|
|
*
|
|
* You are given an additional demo program that does not implement this method.
|
|
* You can run them to see the difference between the two demo programs.
|
|
*/
|
|
// public void fixMap(_________________________) {
|
|
// }
|
|
|
|
/**
|
|
* To move a box in a map.
|
|
*
|
|
* TODO
|
|
*
|
|
* This method will move a box in the map. The box will be moved to the direction specified by the parameter "direction".
|
|
* You must call this method somewhere in movePlayer() method.
|
|
*
|
|
* After this method, a box should be moved to the new position from the coordinate [row, col] according to the direction.
|
|
* For example, if [row, col] is [2, 5] and the direction is 'S', the box should be moved to [3, 5].
|
|
*
|
|
* If a box is moved to a goal, the box should be marked as BOXONGOAL.
|
|
* If a box is moved to a non-goal, the box should be marked as BOX.
|
|
* You should set the original position of the box to ' ' in this method.
|
|
*
|
|
* Note, you may always assume that this method is called when the box can be moved to the direction.
|
|
* During grading, we will never call this method when the box cannot be moved to the direction.
|
|
*/
|
|
public void moveBox(char[][] map, int row, int col, char direction) {
|
|
// int n4;
|
|
// int[] arrn = this.a(row, col, direction);
|
|
// int n5 = arrn[0];
|
|
// map[n5][n4] = map[n5][n4 = arrn[1]] == '.' ? 37 : 64;
|
|
// map[row][col] = map[row][col] == '%' ? 46 : 32;
|
|
}
|
|
|
|
/**
|
|
* To move the player in the map.
|
|
*
|
|
* TODO
|
|
*
|
|
* This method will move the player in the map. The player will be moved to the direction specified by the parameter "direction".
|
|
*
|
|
* After this method, the player should be moved to the new position from the coordinate [row, col] according to the direction.
|
|
* At the same time, the original position of the player should be set to ' '.
|
|
*
|
|
* During the move of the player, it is also possible that a box is also moved.
|
|
*
|
|
* Note, you may always assume that this method is called when the player can be moved to the direction.
|
|
* During grading, we will never call this method when the player cannot be moved to the direction.
|
|
*/
|
|
public void movePlayer(char[][] map, int row, int col, char direction) {
|
|
// int n4;
|
|
// int[] arrn = this.a(row, col, direction);
|
|
// int n5 = arrn[0];
|
|
// if (map[n5][n4 = arrn[1]] == '@' || map[n5][n4] == '%') {
|
|
// this.a(map, n5, n4, direction);
|
|
// }
|
|
// map[n5][n4] = 111;
|
|
// map[row][col] = 32;
|
|
}
|
|
|
|
/**
|
|
* To check if the game is over.
|
|
*
|
|
* TODO
|
|
*
|
|
* This method should return true if the game is over, false otherwise.
|
|
* The condition for game over is that there is no goal left in the map that is not covered by a box.
|
|
*
|
|
* According to this definition, if the number of goal is actually more than the number of boxes,
|
|
* the game will never end even through all boxes are placed on the goals.
|
|
*/
|
|
public boolean gameOver(char[][] map) {
|
|
for (int i2 = 0; i2 < map.length; ++i2) {
|
|
for (int i3 = 0; i3 < map[i2].length; ++i3) {
|
|
if (map[i2][i3] != '.') continue;
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* To count the number of rows in a file.
|
|
*
|
|
* TODO
|
|
*
|
|
* This method should return the number of rows in the file which filename is stated in the argument.
|
|
* If the file is not found, it should return -1.
|
|
*/
|
|
public int numberOfRows(String fileName) {
|
|
try {
|
|
Scanner scanner = new Scanner(new File(fileName));
|
|
int n2 = 0;
|
|
while (scanner.hasNextLine()) {
|
|
++n2;
|
|
scanner.nextLine();
|
|
}
|
|
return n2;
|
|
}
|
|
catch (Exception exception) {
|
|
return -1;
|
|
}
|
|
}
|
|
/**
|
|
* To read a map from a file.
|
|
*
|
|
* TODO
|
|
*
|
|
* This method should return a 2D array of characters which represents the map.
|
|
* This 2D array should be read from the file which filename is stated in the argument.
|
|
* If the file is not found, it should return null.
|
|
*
|
|
* The number of columns in each row may be different. However, there is no restriction on
|
|
* the number of columns that is declared in the array. You can declare the number of columns
|
|
* in your array as you wish, as long as it is enough to store the map.
|
|
*
|
|
* That is, if the map is as follow,
|
|
* ####
|
|
* #.@o#
|
|
* # #
|
|
* ###
|
|
* your array may be declared as
|
|
* char[][] map = {{'#', '#', '#', '#'},
|
|
* {'#', '.', '@', 'o', '#'},
|
|
* {'#', ' ', ' ', '#'},
|
|
* {'#', '#', '#'} };
|
|
* or something like
|
|
* char[][] map = {{'#', '#', '#', '#', ' ', ' ', ' '},
|
|
* {'#', '.', '@', 'o', '#', ' ', ' '},
|
|
* {'#', ' ', ' ', '#', ' ', ' ', ' '},
|
|
* {'#', '#', '#', ' ', ' ', ' ', ' '} };
|
|
*/
|
|
public char[][] readmap(String fileName) {
|
|
return null;
|
|
// int n2 = this.a(string);
|
|
// if (n2 == -1) {
|
|
// return null;
|
|
// }
|
|
// char[][] arrarrc = new char[n2][];
|
|
// try (Scanner scanner = new Scanner(new File(string));){
|
|
// int n3 = 0;
|
|
// while (true) {
|
|
// int n4;
|
|
// String string2;
|
|
// Object object;
|
|
// if (scanner.hasNextLine()) {
|
|
// object = scanner.nextLine();
|
|
// string2 = "";
|
|
// } else {
|
|
// object = arrarrc;
|
|
// return object;
|
|
// }
|
|
// for (n4 = ((String)object).length() - 1; n4 >= 0 && ((String)object).charAt(n4) == ' '; --n4) {
|
|
// }
|
|
// for (int i2 = 0; i2 <= n4; ++i2) {
|
|
// string2 = string2 + ((String)object).charAt(i2);
|
|
// }
|
|
// arrarrc[n3] = string2.toCharArray();
|
|
// ++n3;
|
|
// }
|
|
// }
|
|
// catch (Exception exception) {
|
|
// return null;
|
|
// }
|
|
}
|
|
|
|
/**
|
|
* To find the coordinate of player in the map.
|
|
*
|
|
* TODO
|
|
*
|
|
* This method should return a 2D array that stores the [row, col] of the player in the map.
|
|
* For example, if the map is as follow,
|
|
* ####
|
|
* #.@o#
|
|
* # #
|
|
* ###
|
|
* this method should return {1, 3}.
|
|
*
|
|
* In case there is no player in the map, this method should return null.
|
|
*/
|
|
public int[] findPlayer(char[][] map) {
|
|
for (int i = 0; i < map.length; ++i) {
|
|
for (int j = 0; j < map[i].length; ++j) {
|
|
if (map[i][j] != 'o') continue;
|
|
int[] arrn = new int[]{i, j};
|
|
return arrn;
|
|
}
|
|
}
|
|
int[] arrn = new int[]{-1, -1};
|
|
return arrn;
|
|
}
|
|
|
|
/**
|
|
* To check if a move is valid.
|
|
*
|
|
* TODO
|
|
*
|
|
* This method should return true if the move is valid, false otherwise.
|
|
* The parameter "map" represents the map.
|
|
* The parameter "row" and "col" indicates where the player is.
|
|
* The parameter "direction" indicates the direction of the move.
|
|
* At the end of the method, this method should not change any content of the map.
|
|
*
|
|
* The physics of the game is as follow:
|
|
* 1. The player can only move to a position that is not occupied by a wall or a box.
|
|
* 2. If the player is moving to a position that is occupied by a box, the box can only be moved to a position that is not occupied by a wall or a box.
|
|
*
|
|
* Thus, in the following condition, the player can move to the right
|
|
* o # <-- there is a space
|
|
* o@ # <-- there is a space right to the box.
|
|
* In the following condition, the player cannot move to the right
|
|
* o# <-- there is a wall
|
|
* o@# <-- there is a wall right to the box.
|
|
* o@@ # <-- there is a box right to the box.
|
|
*/
|
|
public boolean isValid(char[][] map, int row, int col, char direction) {
|
|
// return true;
|
|
return this.a(map, row, col, direction, true);
|
|
|
|
}
|
|
/**
|
|
* To print the map.
|
|
*
|
|
* TODO
|
|
*
|
|
* This method should print the map in the console.
|
|
* At the top row, it should print a space followed by the last digit of the column indexes.
|
|
* At the leftmost column, it should print the last two digits of row indexes, aligning to the left.
|
|
*/
|
|
public void printMap(char[][] map) {
|
|
int i;
|
|
if (map == null) {
|
|
return;
|
|
}
|
|
|
|
int map_length = map[0].length;
|
|
|
|
for (i = 1; i < map.length; ++i) {
|
|
if (map_length >= map[i].length) continue;
|
|
map_length = map[i].length;
|
|
}
|
|
|
|
System.out.print(" ");
|
|
|
|
for (i = 0; i < map_length; ++i) {
|
|
// print header row
|
|
System.out.print(i % 10);
|
|
}
|
|
|
|
System.out.println();
|
|
|
|
for (i = 0; i < map.length; ++i) {
|
|
System.out.printf("%-3d", i % 100);
|
|
for (int j = 0; j < map[i].length; ++j) {
|
|
System.out.print(map[i][j]);
|
|
}
|
|
System.out.println();
|
|
}
|
|
}
|
|
|
|
private int[] a(int n2, int n3, int n4) {
|
|
int[] arrn = new int[]{n2, n3};
|
|
switch (n4) {
|
|
case 87: {
|
|
arrn[0] = arrn[0] - 1;
|
|
break;
|
|
}
|
|
case 83: {
|
|
arrn[0] = arrn[0] + 1;
|
|
break;
|
|
}
|
|
case 65: {
|
|
arrn[1] = arrn[1] - 1;
|
|
break;
|
|
}
|
|
case 68: {
|
|
arrn[1] = arrn[1] + 1;
|
|
}
|
|
}
|
|
return arrn;
|
|
}
|
|
|
|
// check if the move is valid
|
|
private boolean a(char[][] arrc, int n2, int n3, char c2, boolean bl) {
|
|
int[] arrn = this.a(n2, n3, c2);
|
|
int n4 = arrn[0];
|
|
int n5 = arrn[1];
|
|
if (n4 < 0 || n4 >= arrc.length || n5 < 0 || n5 >= arrc[n4].length) {
|
|
return false;
|
|
}
|
|
if (arrc[n4][n5] == '#') {
|
|
return false;
|
|
}
|
|
if (arrc[n4][n5] == '@' || arrc[n4][n5] == '%') {
|
|
if (bl) {
|
|
return this.a(arrc, n4, n5, c2, false);
|
|
}
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
}
|