Block Sliding Puzzle

[Peter Shipway]

I have to modify my block sliding puzzle program so the user can solve it, to do this i need to create three methods, one to return if the problem is solved, one to return if the block can move and one to move the block, this program is completely terminal based and I AM NOT ALLOWED TO USE GUI (stupid i know) below is my code (three differnt classes)

  
/**
 * Block class for block sliding puzzle.
 * Part of solution to 1104CIT Project 1, Exercise 3.
 * @author Rodney Topor, August 2004.
 */
public class Block {
    // Instance variables:
    private final String id;        // block identifier
    private final int width;        // block width >= 1
    private final int height;       // block height >= 1
    private int row, col;           // position of top-left square of block
    /** 
     * Creates a block instance.
     * @param id String identifier of block.
     * @param width integer width of block, width >= 1.
     * @param height integer height of block, height >= 1.
     */
    public Block(String id, int width, int height) {
        this.id = id;
        this.width = width;
        this.height = height;
     }
    // Instance methods
    /** Returns id of block. */
    public String id() { return id; }
    /** Returns width of block. */
    public int width() { return width; }
    /** Returns height of block. */
    public int height() { return height; }
    /** Returns current row of block. */
    public int row() { return row; }
    /** Returns current column of block. */
    public int col() { return col; }
    /** 
     * Sets position of block to given position. 
     * @param row Row of new position, row >= 0.
     * @param col Column of new position, col >= 0.
     */
    public void setPosition(final int row, final int col) {
        this.row = row; 
        this.col = col;
    }
    /** Returns block as string (for testing). */
    public String toString() {
        return 
            id + ":" + width + "x" + height + "@(" + row + "," + col + ")";
    } 
}

  
import java.io.*;
import java.util.*;
/**
 * Board description for Blocks, contains
 * methods for creating, printing and solving
 * the block puzzle
 * @author Rodney Topor, August 2004.
 * Modifyed by Peter Shipway, September 2004.
 */
public class Board {
    // The height of the board.
    private final int HEIGHT;
    // The width of the board.
    private final int WIDTH;
    // The array of blocks.
    private final Block[][] blocks;
    // Side of the exit
    String side = "";
    // where the exit starts
    int first;
    // where the exit ends
    int last;
    /** 
     * Creates a board instance, sets the board size, and creates
     * the array of blocks.
     * @param height the height of the board
     * @param width the width of the board.
     * preconditions: board class is intizled.
     * postconditions: constructors are updated wiith new values
     * and the block and grid array's are created.
     */
    public Board(int height, int width) {
        this.HEIGHT = height;
        this.WIDTH = width;
        this.blocks = new Block[HEIGHT][WIDTH]; // (array elements are null)
    }
    /**
     * Adds a block to the array blocks.
     * @param block The block to be added.
     * preconditions: none.
     * postconditions: adds a block to the array of blocks.
     */
    public void add(Block block) {
        final int row = block.row();
        final int col = block.col();
        for (int r = row; r < row+block.height(); r++) 
            for (int c = col; c < col+block.width(); c++)
                blocks[r][c] = block;
    }
    /** 
     * Returns the block at a given position.
     * @param row the row of the block.
     * @param col the col of the block.
     * preconditions: a block exists at the given position.
     * postconditions: returns the block at the position.
     */
    public Block block(int row, int col) {
        return blocks[row][col];
    }
    /**
     * Sets the variables to determine the exit
     * @param s the side of the exit.
     * @param f the first part of the exit.
     * @param l the last part of the exit.
     * preconditions: none
     * postconditions: variables set
     */
    public void setExit(String s, int f, int l){
        side = s;
        first = f;
        last = l;
    }
    /** 
     * Creates a string representation of the board. 
     * preconditions: the array of blocks exist.
     * postconditions returns a string to represent the board.
     */
    public String toString() {
        String s = " "; // The string being constructed.
        // (A more efficient implementation would use a StringBuffer.)
        // Form top boundary
        for (int c = 0; c < WIDTH; c++){
            if (first == c && side.equalsIgnoreCase("u")){
                s += "+";
            }else if (last == c && side.equalsIgnoreCase("u")){
                s += "+";
            }else{
                s += "-";
            }
        }
        s += "\n";
        // Form rows
        for (int r = 0; r < HEIGHT; r++){
            if (first == r && side.equalsIgnoreCase("l")){
                s += "+";
            }else if (last == r && side.equalsIgnoreCase("l")){
                s += "+";
            }else{
                s += "|";
            }
            for (int c = 0; c < WIDTH; c++){
                if (blocks[r][c] == null)
                    s += ".";
                else
                    s += blocks[r][c].id();
            }
            if (first == r && side.equalsIgnoreCase("r")){
                s += "+";
            }else if (last == r && side.equalsIgnoreCase("r")){
                s += "+";
            }else{
                s += "|";
            }
            s += "\n";
        }
        // Form bottom boundary
        s += " ";
        for (int c = 0; c < WIDTH; c++){
            if (first == c && side.equalsIgnoreCase("d")){
                s += "+";
            }else if (last == c && side.equalsIgnoreCase("d")){
                s += "+";
            }else{
                s += "-";
            }
        }
        s += "\n";
        return s;
    }
    /**
     * Returns whether or not a block can move in a direction. 
     * @param id The identifier of the block to move. 
     * @param dir The direction to move the block. 
     * postconditions: the array exists
     * preconditions: true or false returned;
     */
    public boolean canMove(String id, String dir){
        return true;
    }
    /**
     * Moves a block in a direction.  Requires canMove(id, dir) to hold.
     * @param id The identifier of the block to move.
     * @param dir The direction to move the block.
     * preconditions: the array exists
     * postconditions: the block is moved and the array updated
     */
    public void move(String id, String dir){
        
    }
    /**
     * Returns whether or not the problem is solved.
     * preconditions: none
     * postconditions: true of false returned 
     */
    public boolean solved(){
        
        return false;
    }
}

  
import java.io.*;
import java.util.*;
/**
 * Reads the users input then creates
 * an array of blocks, and finally reads
 * the users input to solve the puzzle.
 * @author Rodney Topor, August 2004.
 * Modifyed by Peter Shipway, September 2004.
 */
public class App {
    // Height of board in squares.
    private static final int HEIGHT = 5;
    // Width of board in squares.
    private static final int WIDTH = 4;
    // The board containing the blocks for the problem.
    private final Board board = new Board(HEIGHT, WIDTH);
    // The minimum number of moves to solve the problem.
    int minMoves = 0;
    /* 
     ** Creates an instance of the application and runs it.
     ** preconditions: none.
     ** postconditions: prints out a puzzle and awaits the
     ** users input to solve the puzzle.
     */
    public static void main(String[] args) throws IOException {
        App app = new App();
        app.readProblem(args[0]);
        app.printBoard();
        app.sovlePuzzle();
    }
    /*
     ** Reads problem from standard input and sets board to problem.
     ** precondtiions: none.
     ** postconditions: array of blocks for puzzle is created.
     */
    private void readProblem(String file) throws IOException {
        StringTokenizer st;
        FileReader fr = new FileReader(file);
        BufferedReader in = new BufferedReader(fr);
        // Read blocks
        String line = in.readLine().toUpperCase();
        while (line.charAt(0) != 'Z') {
            st = new StringTokenizer(line);
            String id = st.nextToken();
            int width = Integer.parseInt(st.nextToken());
            int height = Integer.parseInt(st.nextToken());
            int row = Integer.parseInt(st.nextToken());
            int col = Integer.parseInt(st.nextToken());
            Block block = new Block(id, width, height);
            block.setPosition(row, col);
            board.add(block);
            line = in.readLine();
        }
        // Read exit
        st = new StringTokenizer(line);
        st.nextToken(); // "Z"
        String side = st.nextToken();
        int first = Integer.parseInt(st.nextToken());
        int last = Integer.parseInt(st.nextToken());
        board.setExit(side,first,last);
        // Read minimum no. of moves
        line = in.readLine();
        int minMoves = Integer.parseInt(line);
    }
    /*
     ** Prints the board. 
     ** preconditions: puzzle exists.
     ** postconditions: puzzle printed to screen.
     */
    private void printBoard() {
        System.out.print(board.toString());
    }
    /* 
     **
     ** preconditions: puzzle has been printed to screen.
     ** postconditions: blocks moved within the puzzle.
     */
    public void sovlePuzzle() throws IOException{
        BufferedReader in = new BufferedReader(
            new InputStreamReader(System.in));
        int moves = 0;
        String line = in.readLine();
         //while (board.solved() == false)
         //{
            char cid = line.charAt(0);
            String id = "";
            id += cid;
            char cdir = line.charAt(1);
            String dir = "";
            dir += cdir;
            if (board.canMove(id,dir) == true){
                board.move(id,dir);
            }
            moves++;
        //}
        System.out.println("Solved in " + moves + " (min is " + minMoves + " )");
    }
}

As you can see i have a long way to go but i am completely stuck, i know to see if the problem is solved i have to see if the A block (thats a 2 by 2 block) is next to the exit which has a start and finish variable and a side varible, so i just need to check either the row or the coloum next to the start and finish variables for the block with id A (easier said then done atm). For the move method i am thinking of using a swtich statment for the direction. As for the canMove method i have no idea what to do, do i look for a null id varaible to the direction of what the user wants it to move?

As always guys i apreciate the help in a huge way you guys rock

[Peter Shipway]

Ok i have done a bit more in the program however now i am getting errors such as null pointer exception and array out of bounds index, i believe the problem is within my solved method here it is below:

  
import java.io.*;
import java.util.*;
/**
 * Board description for Blocks, contains
 * methods for creating, printing and solving
 * the block puzzle
 * @author Rodney Topor, August 2004.
 * Modifyed by Peter Shipway, September 2004.
 */
public class Board {
    // The height of the board.
    private final int HEIGHT;
    // The width of the board.
    private final int WIDTH;
    // The array of blocks.
    private final Block[][] blocks;
    // Side of the exit
    String side = "";
    // where the exit starts
    int first;
    // where the exit ends
    int last;
    /** 
     * Creates a board instance, sets the board size, and creates
     * the array of blocks.
     * @param height the height of the board
     * @param width the width of the board.
     * preconditions: board class is intizled.
     * postconditions: constructors are updated wiith new values
     * and the block and blocks array's are created.
     */
    public Board(int height, int width) {
        this.HEIGHT = height;
        this.WIDTH = width;
        this.blocks = new Block[HEIGHT][WIDTH]; // (array elements are null)
    }
    /**
     * Adds a block to the array blocks.
     * @param block The block to be added.
     * preconditions: none.
     * postconditions: adds a block to the array of blocks.
     */
    public void add(Block block) {
        final int row = block.row();
        final int col = block.col();
        for (int r = row; r < row+block.height(); r++) 
            for (int c = col; c < col+block.width(); c++)
                blocks[r][c] = block;
    }
    /** 
     * Returns the block at a given position.
     * @param row the row of the block.
     * @param col the col of the block.
     * preconditions: a block exists at the given position.
     * postconditions: returns the block at the position.
     */
    public Block block(int row, int col) {
        return blocks[row][col];
    }
    /**
     * Sets the variables to determine the exit
     * @param s the side of the exit.
     * @param f the first part of the exit.
     * @param l the last part of the exit.
     * preconditions: none
     * postconditions: variables set
     */
    public void setExit(String s, int f, int l){
        side = s;
        first = f;
        last = l;
    }
    /** 
     * Creates a string representation of the board. 
     * preconditions: the array of blocks exist.
     * postconditions returns a string to represent the board.
     */
    public String toString() {
        String s = " "; // The string being constructed.
        // (A more efficient implementation would use a StringBuffer.)
        // Form top boundary
        for (int c = 0; c < WIDTH; c++){
            if (first == c && side.equalsIgnoreCase("u")){
                s += "+";
            }else if (last == c && side.equalsIgnoreCase("u")){
                s += "+";
            }else{
                s += "-";
            }
        }
        s += "\n";
        // Form rows
        for (int r = 0; r < HEIGHT; r++){
            if (first == r && side.equalsIgnoreCase("l")){
                s += "+";
            }else if (last == r && side.equalsIgnoreCase("l")){
                s += "+";
            }else{
                s += "|";
            }
            for (int c = 0; c < WIDTH; c++){
                if (blocks[r][c] == null)
                    s += ".";
                else
                    s += blocks[r][c].id();
            }
            if (first == r && side.equalsIgnoreCase("r")){
                s += "+";
            }else if (last == r && side.equalsIgnoreCase("r")){
                s += "+";
            }else{
                s += "|";
            }
            s += "\n";
        }
        // Form bottom boundary
        s += " ";
        for (int c = 0; c < WIDTH; c++){
            if (first == c && side.equalsIgnoreCase("d")){
                s += "+";
            }else if (last == c && side.equalsIgnoreCase("d")){
                s += "+";
            }else{
                s += "-";
            }
        }
        s += "\n";
        return s;
    }
    /**
     * Returns whether or not a block can move in a direction. 
     * @param id The identifier of the block to move. 
     * @param dir The direction to move the block. 
     * postconditions: the array exists
     * preconditions: true or false returned;
     */
    public boolean canMove(String id, String dir){
        Block block = returnBlock(id);
        final int row = block.row();
        final int col = block.col();
 
        if (dir.equalsIgnoreCase("u") && (blocks[row-1][col] == null|| blocks[row-1][col] == block)){
            return true;
        }else if (dir.equalsIgnoreCase("l") && (blocks[row][col-1] == null|| blocks[row][col-1] == block)){
            return true;
        }else if (dir.equalsIgnoreCase("d") && (blocks[row+1][col] == null|| blocks[row+1][col] == block)){
            return true;
        }else if (dir.equalsIgnoreCase("r") && (blocks[row][col+1] == null|| blocks[row][col+1] == block)){
            return true;
        }else{
            return false;
        }
    }
    /**
     * Moves a block in a direction.  Requires canMove(id, dir) to hold.
     * @param id The identifier of the block to move.
     * @param dir The direction to move the block.
     * preconditions: the array exists
     * postconditions: the block is moved and the array updated
     */
    public void move(String id, String dir) {
        Block block = returnBlock(id);
        final int row = block.row();
        final int col = block.col();
        char dirc = dir.charAt(0);
        switch (dirc) {
            case 'u': // Up
                // Move the block one position up
                for (int r = row; r < row+block.height(); r++) {
                    for (int c = col; c < col+block.width(); c++) {
                        blocks[r-1][c] = block;
                    }
                }
                // Clear the array elements below the block
                for (int c = col; c < col+block.width(); c++) {
                    blocks[row+block.height()-1][c] = null;
                }
                // Update the block position
                block.setPosition(row-1, col);
                // Exit the switch statement
                break;
            
            case 'l':
                for (int r = row; r < row+block.height(); r++) {
                    for (int c = col; c < col+block.width(); c++) {
                        blocks[r][c-1] = block;
                    }
                }
                // Clear the array elements below the block
                for (int r = row; r < row+block.height(); r++){
                    blocks[r][col+block.width()-1] = null;
                }
                // Update the block position
                block.setPosition(row, col-1);
                // Exit the switch statement
                break;
            
            case 'r':
               for (int r = row; r < row+block.height(); r++) {
                    for (int c = col; c < col+block.width(); c++) {
                        blocks[r][c+1] = block;
                    }
                }
                // Clear the array elements below the block
                for (int r = row; r < row+block.height(); r++){
                    blocks[r][col+block.width()-2] = null;
                }
                // Update the block position
                block.setPosition(row, col+1);
                // Exit the switch statement
                break;
            
            case 'd':
                for (int r = row; r < row+block.height(); r++) {
                    for (int c = col; c < col+block.width(); c++) {
                       blocks[r+1][c] = block;
                    }
                }
                // Clear the array elements above the block
                for (int c = col; c < col+block.width(); c++){
                    if(block.width() == 1){
                        blocks[row+block.height()-2][c] = null;
                    }else{ 
                        blocks[row+block.height()-1][c] = null;
                    }
                }
                // Update the block position
                block.setPosition(row+1, col);
                // Exit the switch statement
                break;
        }
    }
    /**
     * Returns whether or not the problem is solved.
     * preconditions: none
     * postconditions: true of false returned 
     */
    public boolean solved(){
        for (int i = 0; i < blocks.length; i++) {
            for (int j = 0; j < blocks[i].length; j++) {
                Block block = blocks[i][j];
                if(block.width() == 2 || block.height() == 2) {
                    if (block.row() == first && block.col() == last) {
                        return true;
                    }else{
                        return false;
                    }
                }
            }
        }
        return false;
    }
    /**
     * Returns the paramters of the block
     * preconditions: block id passed
     * postconditions: returns the paraimaters of the block
     */
     public Block returnBlock(String id){
        for (int i = 0; i < blocks.length; i++) {
              for (int j = 0; j < blocks[i].length; j++) {
                Block b = (Block) blocks[i][j];
                if(b != null) {
                    if(b.id().equalsIgnoreCase(id)) {
                        return b;
                    }
                }
             }
        }
        return null;
     }
}

I can move some blocks around and other ones i cant eg in a problem with just one 2x2 block i can't move it at all :S

[JulianInactive KennedyInactive]

Peter,

I doubt you're going to get much help if you post masses of code like that. If you post a small snippet of code clearly highlighting a problem that you're really struggling with (including the exact error you're getting) I might be inclined to help. Personally I'm not prepared to read your whole assignment.

Jules

[Peter Shipway]

ok thanks for the advice i have norrwed my problem to move method the i need to be reading the grid backwords instead of forwards because it reads each block then moves it in the direction but only if it is null eg

....
.AA.
.AA.
....
....

becomes

.AA.
.AA.
....
....
....

when moved up but when moved down it bcomes

....
.AA.
....
.AA.
....

because it sees that there isnt a null value below the first set of A's but there is below the second one

  
ase 'u': // Up
                // Move the block one position up
                for (int r = row-1; r > row+block.height(); r--) {
                    for (int c = col; c > col+block.width(); c--) {
                        blocks[r+1][c] = block;
                    }
                }
                // Clear the array elements below the block
                for (int c = col; c < col+block.width(); c++) {
                    blocks[row+block.height()+1][c] = null;
                }
                // Update the block position
                block.setPosition(row+1, col);
                // Exit the switch statement
                break;
            
            case 'l':
                for (int r = row; r < row+block.height(); r++) {
                    for (int c = col; c < col+block.width(); c++) {
                        blocks[r][c-1] = block;
                    }
                }
                // Clear the array elements below the block
                for (int r = row; r < row+block.height(); r++){
                    blocks[r][col+block.width()-1] = null;
                }
                // Update the block position
                block.setPosition(row, col-1);
                // Exit the switch statement
                break;
            
            case 'r':
               for (int r = row; r < row+block.height(); r++) {
                    for (int c = col; c < col+block.width(); c++) {
                        blocks[r][c+1] = block;
                    }
                }
                // Clear the array elements below the block
                for (int r = row; r < row+block.height(); r++){
                    blocks[r][col+block.width()-2] = null;
                }
                // Update the block position
                block.setPosition(row, col+1);
                // Exit the switch statement
                break;

That is the code to move the block up and down the up statment works fine but as i said the down dosent i know i need to go through the array backwards but i dont understand how to do it.

[fred rosenberger]

i didn't really look at the code, but here's some things to think about...

if you go forward through an array like this:

for (int r = row; r < row+block.height(); r++){

then you can go backwards through an array like this:

for (int r = row+block.height(); r > row ; r--){

in other words, start at the other end and count down.


now, a null pointer error means that you have a reference to an object, but never CREATED an object. the error message should tell you at the least what line the error happened, which should help you figure out what reference is causing the problem.

In other words, somewhere in your code you have a line like

Foo myObject;

then you try and use a method in myObject, with the dot operator:

myObject.printMe();

note that you may even have something in your code that you THINK will assign an object to this reference, but it might fail and return a null...

myObject = helperObject.getNextWord();

if there is no next word, this method returns a null, so now myObject refers to a null... you see the problem? You need to look at where you're being told the nullPointer exception is.

as to the array out of bounds, again, look at the line where you are being told this happens. how big IS the array? maybe you could print out the real size and what your index is at each step. remember that arrays are 0 indexed, so if the size is 10, you want to run from i = 0 to i < 10