Level

package com.cs2114.dungeonescape;



// -------------------------------------------------------------------------
/**
 * Level handles all of the data manipulation of the dungeon escape game
 *
 * @author Joe Bruzek, Yash Pant, Marcus Stewart
 * @version Dec 4, 2013
 */
public class Level
{

    private Location                   currentLocation;
    private Location                   start;
    private Location                   goal;
    private Cell[][]                   dungeon;
    private DoublyLinkedList<Location> path;


    // ----------------------------------------------------------
    /**
     * Create a new Level object.
     *
     * @param level
     *            a string representation of the level
     */
    public Level(String level)
    {
        dungeon = new Cell[20][20];

        for (int y = 0; y < 20; y++)
        {
            for (int x = 0; x < 20; x++)
            {
                char current = level.charAt(x + y * 20);

                if (current == '3')
                {
                    dungeon[x][y] = Cell.WALL;
                }
                else if (current == '2')
                {
                    dungeon[x][y] = Cell.HAZARD;
                }
                else if (current == '1')
                {
                    dungeon[x][y] = Cell.OPEN_PATH;
                }
            }
        }

        start =
            new Location(
                Character.getNumericValue(level.charAt(400))
                    + Character.getNumericValue(level.charAt(401))
                    + Character.getNumericValue(level.charAt(402)),
                Character.getNumericValue(level.charAt(403))
                    + Character.getNumericValue(level.charAt(404))
                    + Character.getNumericValue(level.charAt(405)));

        goal =
            new Location(
                Character.getNumericValue(level.charAt(406))
                    + Character.getNumericValue(level.charAt(407))
                    + Character.getNumericValue(level.charAt(408)),
                Character.getNumericValue(level.charAt(409))
                    + Character.getNumericValue(level.charAt(410))
                    + Character.getNumericValue(level.charAt(411)));

        currentLocation = start;
        path = new DoublyLinkedList<Location>();
        path.add(currentLocation);
    }


    /**
     * reset the path
     */
    public void resetPath()
    {
        path = new DoublyLinkedList<Location>();
        setCurrentLocation(start);
    }


    /**
     * set the current location
     *
     * @param loc
     *            the location to be the new current
     */
    public void setCurrentLocation(Location loc)
    {
        currentLocation = loc;
        path.add(loc);
    }


    /**
     * return the current location in a location object
     *
     * @return the current location
     */
    public Location getCurrentLocation()
    {
        return currentLocation;
    }


    /**
     * gets the starting location for this level
     *
     * @return the location of the start
     */
    public Location getStart()
    {
        return start;
    }


    /**
     * gets the goal location for this level
     *
     * @return the location of the goal
     */
    public Location getGoal()
    {
        return goal;
    }


    /**
     * return the list that holds the path of the dungeon explorer
     *
     * @return the path through the dungeon
     */
    public DoublyLinkedList<Location> getPath()
    {
        return path;
    }


    /**
     * set the cell to a specific cell value If the cell is the start or the
     * goal, nothing happens
     *
     * @param loc
     *            the location to have the cell changed
     * @param cell
     *            the cell value for the location to be changed to
     */
    public void setCell(Location loc, Cell cell)
    {
        if (!loc.equals(start) && !loc.equals(goal))
        {
            dungeon[loc.x()][loc.y()] = cell;
        }
    }


    /**
     * set the goal location cannot be a wall or a hazard
     *
     * @param loc
     *            the location to place the goal
     */
    public void setGoal(Location loc)
    {
        if (getCell(loc) != Cell.WALL && getCell(loc) != Cell.HAZARD)
        {
            goal = loc;
        }
    }


    /**
     * set the start location cannot be a wall or a hazard
     *
     * @param loc
     *            the location to place the start
     */
    public void setStart(Location loc)
    {
        if (getCell(loc) != Cell.WALL && getCell(loc) != Cell.HAZARD)
        {
            start = loc;
            path.clear();
            setCurrentLocation(loc);
        }
    }


    /**
     * get the value of the cell at the location
     *
     * @param loc
     *            the location to get the cell value
     * @return the cell at the location
     */
    public Cell getCell(Location loc)
    {
        return dungeon[loc.x()][loc.y()];
    }


    /**
     * restart the dungeon level all path is removed and changed to open path
     * start and goal are reset to their original locations
     *
     * @param level
     *            sting representation of the level
     */
    public void restart(String level)
    {
        for (int y = 0; y < 20; y++)
        {
            for (int x = 0; x < 20; x++)
            {
                char current = level.charAt(x + y * 20);

                if (current == '3')
                {
                    dungeon[x][y] = Cell.WALL;
                }
                else if (current == '2')
                {
                    dungeon[x][y] = Cell.HAZARD;
                }
                else if (current == '1')
                {
                    dungeon[x][y] = Cell.OPEN_PATH;
                }
            }
        }

        start = new Location(level.charAt(401), level.charAt(401));
        goal = new Location(level.charAt(402), level.charAt(403));

        path.clear();
        currentLocation = start;
    }


    /**
     * move to the east adds the farthest east cell that can be moved to to the
     * top of the path
     */
    public void east()
    {
        int x = currentLocation.x();
        int y = currentLocation.y();
        boolean temp = true;

        while (temp)
        {
            if ((x == goal.x() && y == goal.y())
                || getCell(new Location(x + 1, y)).equals(Cell.WALL))
            {
                path.add(new Location(x, y));
                currentLocation = new Location(x, y);
                temp = false;
                x++;
            }
            else
            {
                x++;
            }
        }
    }


    /**
     * move to the west adds the farthest west cell that can be moved to to the
     * top of the path
     */
    public void west()
    {
        int x = currentLocation.x();
        int y = currentLocation.y();
        boolean temp = true;

        while (temp)
        {
            if ((x == goal.x() && y == goal.y())
                || getCell(new Location(x - 1, y)).equals(Cell.WALL))
            {
                path.add(new Location(x, y));
                currentLocation = new Location(x, y);
                temp = false;
                x--;
            }
            else
            {
                x--;
            }
        }
    }


    /**
     * move to the north adds the farthest north cell that can be moved to to
     * the top of the path
     */
    public void north()
    {
        int x = currentLocation.x();
        int y = currentLocation.y();
        boolean temp = true;

        while (temp)
        {
            if ((x == goal.x() && y == goal.y())
                || getCell(new Location(x, y - 1)).equals(Cell.WALL))
            {
                path.add(new Location(x, y));
                currentLocation = new Location(x, y);
                temp = false;
            }
            else
            {
                y--;
            }
        }
    }


    /**
     * move to the south adds the farthest south cell that can be moved to to
     * the top of the path
     */
    public void south()
    {
        int x = currentLocation.x();
        int y = currentLocation.y();
        boolean temp = true;

        while (temp)
        {
            if ((x == goal.x() && y == goal.y())
                || getCell(new Location(x, y + 1)).equals(Cell.WALL))
            {
                path.add(new Location(x, y));
                currentLocation = new Location(x, y);
                temp = false;
            }
            else
            {
                y++;
            }
        }
    }

}