Arcturus-Community/src/main/java/com/eu/habbo/habbohotel/rooms/RoomLayout.java

package com.eu.habbo.habbohotel.rooms;

import com.eu.habbo.Emulator;
import com.eu.habbo.habbohotel.bots.Bot;
import com.eu.habbo.habbohotel.pets.Pet;
import com.eu.habbo.habbohotel.users.Habbo;
import gnu.trove.set.hash.THashSet;

import java.awt.*;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.*;
import java.util.List;

public class RoomLayout
{
    public static double MAXIMUM_STEP_HEIGHT = 1.1;
    public static boolean ALLOW_FALLING = true;
    protected static final int BASICMOVEMENTCOST = 10;
    protected static final int DIAGONALMOVEMENTCOST = 14;

    public  boolean CANMOVEDIAGONALY = true;
    private String name;
    private short doorX;
    private short doorY;
    private short doorZ;
    private int doorDirection;
    private String heightmap;
    private int mapSize;
    private int mapSizeX;
    private int mapSizeY;
    private RoomTile[][] roomTiles;
    private RoomTile doorTile;
    private Room room;

    public RoomLayout(ResultSet set, Room room) throws SQLException
    {
        this.room = room;
        try
        {
            this.name = set.getString("name");
            this.doorX = set.getShort("door_x");
            this.doorY = set.getShort("door_y");

            this.doorDirection = set.getInt("door_dir");
            this.heightmap = set.getString("heightmap");

            this.parse();
        }
        catch (Exception e)
        {
            Emulator.getLogging().logErrorLine(e);
        }
    }

    public void parse()
    {
        String[] modelTemp = this.heightmap.replace("\n", "").split(Character.toString('\r'));

        this.mapSize = 0;
        this.mapSizeX = modelTemp[0].length();
        this.mapSizeY = modelTemp.length;
        this.roomTiles = new RoomTile[this.mapSizeX][this.mapSizeY];

        for (short y = 0; y < this.mapSizeY; y++)
        {
            if(modelTemp[y].isEmpty() || modelTemp[y].equalsIgnoreCase("\r"))
            {
                continue;
            }

            for (short x = 0; x < this.mapSizeX; x++)
            {
                if(modelTemp[y].length() != this.mapSizeX)
                {
                    break;
                }

                String square = modelTemp[y].substring(x, x + 1).trim().toLowerCase();
                RoomTileState state = RoomTileState.OPEN;
                short height = 0;
                if (square.equalsIgnoreCase("x"))
                {
                    state = RoomTileState.INVALID;
                }
                else
                {
                    if (square.isEmpty()) {
                        height = 0;
                    }
                    else if (Emulator.isNumeric(square))
                    {
                        height = Short.parseShort(square);
                    }
                    else
                    {
                        height = (short) (10 + "ABCDEFGHIJKLMNOPQRSTUVWXYZ".indexOf(square.toUpperCase()));
                    }
                }
                this.mapSize += 1;

                this.roomTiles[x][y] = new RoomTile(x, y, height, state, true);
            }
        }

        this.doorTile = this.roomTiles[this.doorX][this.doorY];

        if (this.doorTile != null)
        {
            this.doorTile.setAllowStack(false);
            RoomTile doorFrontTile = this.getTileInFront(this.doorTile, this.doorDirection);

            if (doorFrontTile != null && this.tileExists(doorFrontTile.x, doorFrontTile.y))
            {
                if (this.roomTiles[doorFrontTile.x][doorFrontTile.y].state != RoomTileState.INVALID)
                {
                    if (this.doorZ != this.roomTiles[doorFrontTile.x][doorFrontTile.y].z || this.roomTiles[this.doorX][this.doorY].state != this.roomTiles[doorFrontTile.x][doorFrontTile.y].state)
                    {
                        this.doorZ = this.roomTiles[doorFrontTile.x][doorFrontTile.y].z;
                        this.roomTiles[this.doorX][this.doorY].state = RoomTileState.OPEN;
                    }
                }
            }
        }
    }

    public String getName()
    {
        return this.name;
    }

    public short getDoorX()
    {
        return this.doorX;
    }

    public void setDoorX(short doorX)
    {
        this.doorX = doorX;
    }

    public short getDoorY()
    {
        return this.doorY;
    }

    public void setDoorY(short doorY)
    {
        this.doorY = doorY;
    }

    public int getDoorZ()
    {
        return this.doorZ;
    }

    public RoomTile getDoorTile()
    {
        return this.doorTile;
    }

    public int getDoorDirection()
    {
        return this.doorDirection;
    }

    public void setDoorDirection(int doorDirection)
    {
        this.doorDirection = doorDirection;
    }

    public void setHeightmap(String heightMap)
    {
        this.heightmap = heightMap;
    }

    public String getHeightmap()
    {
        return this.heightmap;
    }

    public int getMapSize()
    {
        return this.mapSize;
    }

    public int getMapSizeX()
    {
        return this.mapSizeX;
    }

    public int getMapSizeY()
    {
        return this.mapSizeY;
    }

    public short getHeightAtSquare(int x, int y)
    {
        if(x < 0 ||
           y < 0 ||
           x >= this.getMapSizeX() ||
           y >= this.getMapSizeY())
            return 0;

        return this.roomTiles[x][y].z;
    }

    public double getStackHeightAtSquare(int x, int y)
    {
        if(x < 0 ||
                y < 0 ||
                x >= this.getMapSizeX() ||
                y >= this.getMapSizeY())
            return 0;

        return this.roomTiles[x][y].getStackHeight();
    }

    public double getRelativeHeightAtSquare(int x, int y)
    {
        if(x < 0 ||
                y < 0 ||
                x >= this.getMapSizeX() ||
                y >= this.getMapSizeY())
            return 0;

        return this.roomTiles[x][y].relativeHeight();
    }

    public RoomTile getTile(short x, short y)
    {
        if (this.tileExists(x, y))
        {
            return this.roomTiles[x][y];
        }

        return null;
    }

    public boolean tileExists(short x, short y)
    {
        return !(x < 0 || y < 0 || x >= this.getMapSizeX() || y >= this.getMapSizeY());
    }

    public boolean tileWalkable(short x, short y)
    {
        return this.tileExists(x, y) && this.roomTiles[x][y].state == RoomTileState.OPEN && this.roomTiles[x][y].isWalkable();
    }

    public boolean isVoidTile(short x, short y)
    {
        if (!this.tileExists(x, y)) return true;
        return this.roomTiles[x][y].state == RoomTileState.INVALID;
    }

    public RoomTileState getStateAt(short x, short y)
    {
        return this.roomTiles[x][y].state;
    }
    public String getRelativeMap()
    {
        return this.heightmap.replace("\r\n", "\r");
    }

    public final Deque<RoomTile> findPath(RoomTile oldTile, RoomTile newTile, RoomTile goalLocation, RoomUnit roomUnit)
    {
        LinkedList<RoomTile> openList = new LinkedList<>();
        try
        {
            if (this.room == null || !this.room.isLoaded() || oldTile == null || newTile == null || oldTile.equals(newTile) || newTile.state == RoomTileState.INVALID)
                return openList;

            List<RoomTile> closedList = new LinkedList<>();

            openList.add(oldTile.copy());

            long startMillis = System.currentTimeMillis();
            while (true)
            {
                if (System.currentTimeMillis() - startMillis > 50)
                {
                    return new LinkedList<>();
                }

                RoomTile current = this.lowestFInOpen(openList);
                openList.remove(current);

                if ((current.x == newTile.x) && (current.y == newTile.y))
                {
                    return this.calcPath(this.findTile(openList, oldTile.x, oldTile.y), current);
                }

                List<RoomTile> adjacentNodes = this.getAdjacent(openList, current, newTile);

                for (RoomTile currentAdj : adjacentNodes)
                {
                    if (closedList.contains(currentAdj)) continue;

                    if(roomUnit.canOverrideTile(currentAdj) || (currentAdj.state != RoomTileState.BLOCKED && currentAdj.x == doorX && currentAdj.y == doorY)) {
                        currentAdj.setPrevious(current);
                        currentAdj.sethCosts(this.findTile(openList, newTile.x, newTile.y));
                        currentAdj.setgCosts(current);
                        openList.add(currentAdj);
                        continue;
                    }

                    //If the tile is sitable or layable and its not our goal tile, we cannot walk over it.
                    if (!currentAdj.equals(goalLocation) && (currentAdj.state == RoomTileState.BLOCKED || currentAdj.state == RoomTileState.SIT || currentAdj.state == RoomTileState.LAY))
                    {
                        closedList.add(currentAdj);
                        openList.remove(currentAdj);
                        continue;
                    }
                    ////if (!room.getLayout().tileWalkable((short) currentAdj.x, (short) currentAdj.y)) continue;

                    //Height difference.
                    double height = currentAdj.getStackHeight() - current.getStackHeight();

                    //If we are not allowed to fall and the height difference is bigger than the maximum stepheight, continue.
                    if (!ALLOW_FALLING && height < - MAXIMUM_STEP_HEIGHT) continue;

                    //If the step difference is bigger than the maximum step height, continue.
                    if (currentAdj.state == RoomTileState.OPEN && height > MAXIMUM_STEP_HEIGHT) continue;

                    //Check if the tile has habbos.
                    if (currentAdj.hasUnits() && (!this.room.isAllowWalkthrough() || currentAdj.equals(goalLocation)))
                    {
                        closedList.add(currentAdj);
                        openList.remove(currentAdj);
                        continue;
                    }

                    //if (room.hasPetsAt(currentAdj.x, currentAdj.y)) continue;

                    if (!openList.contains(currentAdj))
                    {
                        currentAdj.setPrevious(current);
                        currentAdj.sethCosts(this.findTile(openList, newTile.x, newTile.y));
                        currentAdj.setgCosts(current);
                        openList.add(currentAdj);
                    }
                    else if (currentAdj.getgCosts() > currentAdj.calculategCosts(current))
                    {
                        currentAdj.setPrevious(current);
                        currentAdj.setgCosts(current);
                    }
                }
                if (openList.isEmpty())
                {
                    return new LinkedList<>();
                }
            }
        }
        catch(Exception e)
        {
            Emulator.getLogging().logErrorLine(e);
        }
        return new LinkedList<>();
    }

    private RoomTile findTile(List<RoomTile> tiles, short x, short y)
    {
        for (RoomTile tile : tiles)
        {
            if (x == tile.x && y == tile.y)
            {
                return tile;
            }
        }

        RoomTile tile = this.getTile(x, y);

        if (tile != null)
        {
            return tile.copy();
        }
        return null;
    }

    private Deque<RoomTile> calcPath(RoomTile start, RoomTile goal)
    {
        LinkedList<RoomTile> path = new LinkedList<>();
        if (start == null)
            return path;

        RoomTile curr = goal;
        while (curr != null)
        {
            path.addFirst(this.getTile(curr.x, curr.y));
            curr = curr.getPrevious();
            if ((curr != null) && (curr.equals(start))) {
                return path;
            }
        }
        return path;
    }

    private RoomTile lowestFInOpen(List<RoomTile> openList)
    {
        if(openList == null)
            return null;

        RoomTile cheapest = openList.get(0);
        for (RoomTile anOpenList : openList)
        {
            if (anOpenList.getfCosts() < cheapest.getfCosts())
            {
                cheapest = anOpenList;
            }
        }
        return cheapest;
    }

    private List<RoomTile> getAdjacent(List<RoomTile> openList, RoomTile node, RoomTile nextTile)
    {
        short x = node.x;
        short y = node.y;
        List<RoomTile> adj = new LinkedList<>();
        if (x > 0)
        {
            RoomTile temp = this.findTile(openList, (short) (x - 1), y);
            if (temp != null && temp.state != RoomTileState.BLOCKED && temp.state != RoomTileState.INVALID)
            {
                if (temp.state != RoomTileState.SIT || nextTile.getStackHeight() - node.getStackHeight() <= 2.0)
                {
                    temp.isDiagonally(false);
                    if (!adj.contains(temp))
                        adj.add(temp);
                }
            }
        }
        if (x < this.mapSizeX)
        {
            RoomTile temp = this.findTile(openList, (short) (x + 1), y);
            if (temp != null && temp.state != RoomTileState.BLOCKED && temp.state != RoomTileState.INVALID)
            {
                if (temp.state != RoomTileState.SIT || nextTile.getStackHeight() - node.getStackHeight() <= 2.0)
                {
                    temp.isDiagonally(false);
                    if (!adj.contains(temp))
                        adj.add(temp);
                }
            }
        }
        if (y > 0)
        {
            RoomTile temp = this.findTile(openList, x, (short) (y - 1));
            if (temp != null && temp.state != RoomTileState.BLOCKED && temp.state != RoomTileState.INVALID)
            {
                if (temp.state != RoomTileState.SIT || nextTile.getStackHeight() - node.getStackHeight() <= 2.0)
                {
                    temp.isDiagonally(false);
                    if (!adj.contains(temp))
                        adj.add(temp);
                }
            }
        }
        if (y < this.mapSizeY)
        {
            RoomTile temp = this.findTile(openList, x, (short) (y + 1));
            if (temp != null && temp.state != RoomTileState.BLOCKED && temp.state != RoomTileState.INVALID)
            {
                if (temp.state != RoomTileState.SIT || nextTile.getStackHeight() - node.getStackHeight() <= 2.0)
                {
                    temp.isDiagonally(false);
                    if (!adj.contains(temp))
                        adj.add(temp);
                }
            }
        }
        if (this.CANMOVEDIAGONALY)
        {
            if ((x < this.mapSizeX) && (y < this.mapSizeY))
            {
                RoomTile offX = this.findTile(openList, (short) (x + 1), y);
                RoomTile offY = this.findTile(openList, x, (short) (y+1));
                if (offX != null && offY != null && (offX.isWalkable() || offY.isWalkable()))
                {
                    RoomTile temp = this.findTile(openList, (short) (x + 1), (short) (y + 1));
                    if (temp != null && temp.state != RoomTileState.BLOCKED && temp.state != RoomTileState.INVALID)
                    {
                        if (temp.state != RoomTileState.SIT || nextTile.getStackHeight() - node.getStackHeight() <= 2.0)
                        {
                            temp.isDiagonally(true);
                            if (!adj.contains(temp))
                                adj.add(temp);
                        }
                    }
                }
            }
            if ((x > 0) && (y > 0))
            {
                RoomTile offX = this.findTile(openList, (short) (x - 1), y);
                RoomTile offY = this.findTile(openList, x, (short) (y - 1));
                if (offX != null && offY != null && (offX.isWalkable() || offY.isWalkable()))
                {
                    RoomTile temp = this.findTile(openList, (short) (x - 1), (short) (y - 1));
                    if (temp != null && temp.state != RoomTileState.BLOCKED && temp.state != RoomTileState.INVALID)
                    {
                        if (temp.state != RoomTileState.SIT || nextTile.getStackHeight() - node.getStackHeight() <= 2.0)
                        {
                            temp.isDiagonally(true);
                            if (!adj.contains(temp))
                                adj.add(temp);
                        }
                    }
                }
            }
            if ((x > 0) && (y < this.mapSizeY))
            {
                RoomTile offX = this.findTile(openList, (short) (x - 1), y);
                RoomTile offY = this.findTile(openList, x, (short) (y+1));
                if (offX != null && offY != null && (offX.isWalkable() || offY.isWalkable()))
                {
                    RoomTile temp = this.findTile(openList, (short) (x - 1), (short) (y + 1));
                    if (temp != null && temp.state != RoomTileState.BLOCKED && temp.state != RoomTileState.INVALID)
                    {
                        if (temp.state != RoomTileState.SIT || nextTile.getStackHeight() - node.getStackHeight() <= 2.0)
                        {
                            temp.isDiagonally(true);
                            if (!adj.contains(temp))
                                adj.add(temp);
                        }
                    }
                }
            }
            if ((x < this.mapSizeX) && (y > 0))
            {
                RoomTile offX = this.findTile(openList, (short) (x + 1), y);
                RoomTile offY = this.findTile(openList, x, (short) (y - 1));
                if (offX != null && offY != null && (offX.isWalkable() || offY.isWalkable()))
                {
                    RoomTile temp = this.findTile(openList, (short) (x + 1), (short) (y - 1));
                    if (temp != null && temp.state != RoomTileState.BLOCKED && temp.state != RoomTileState.INVALID)
                    {
                        if (temp.state != RoomTileState.SIT || nextTile.getStackHeight() - node.getStackHeight() <= 2.0)
                        {
                            temp.isDiagonally(true);
                            if (!adj.contains(temp))
                                adj.add(temp);
                        }
                    }
                }
            }
        }
        return adj;
    }

    public void moveDiagonally(boolean value)
    {
        this.CANMOVEDIAGONALY = value;
    }

    public static boolean squareInSquare(Rectangle outerSquare, Rectangle innerSquare)
    {
        if(outerSquare.x > innerSquare.x)
            return false;

        if(outerSquare.y > innerSquare.y)
            return false;

        if(outerSquare.x + outerSquare.width < innerSquare.x + innerSquare.width)
            return false;

        if(outerSquare.y + outerSquare.height < innerSquare.y + innerSquare.height)
            return false;

        return true;
    }

    public static boolean tileInSquare(Rectangle square, RoomTile tile)
    {
        return (square.contains(tile.x, tile.y));
    }

    public static boolean pointInSquare(int x1, int y1, int x2, int y2, int pointX, int pointY)
    {
        return (pointX >= x1 && pointY >= y1) && (pointX <= x2 && pointY <= y2);
    }

    public static boolean tilesAdjecent(RoomTile one, RoomTile two)
    {
        return !(one == null || two == null) && !(Math.abs(one.x - two.x) > 1) && !(Math.abs(one.y - two.y) > 1);
    }

    public RoomTile getTileInFront(RoomTile tile, int rotation)
    {
        return this.getTileInFront(tile, rotation, 0);
    }

    public RoomTile getTileInFront(RoomTile tile, int rotation, int offset)
    {
        int offsetX = 0;
        int offsetY = 0;

        rotation = rotation % 8;
        switch (rotation)
        {
            case 0: offsetY--; break;
            case 1: offsetX++; offsetY--; break;
            case 2: offsetX++; break;
            case 3: offsetX++; offsetY++; break;
            case 4: offsetY++; break;
            case 5: offsetX--; offsetY++; break;
            case 6: offsetX--; break;
            case 7: offsetX--; offsetY--; break;
        }

        short x = tile.x;
        short y = tile.y;

        for (int i = 0; i <= offset; i++)
        {
            x += offsetX;
            y += offsetY;
        }

        return this.getTile(x, y);
    }

    public List<RoomTile> getTilesInFront(RoomTile tile, int rotation, int amount)
    {
        List<RoomTile> tiles = new ArrayList<>(amount);
        RoomTile previous = tile;
        for (int i = 0; i < amount; i++)
        {
            RoomTile t = this.getTileInFront(previous, rotation, i);

            if (t != null)
            {
                tiles.add(t);
            }
            else
            {
                break;
            }
        }

        return tiles;
    }

    public List<RoomTile> getTilesAround(RoomTile tile)
    {
        return getTilesAround(tile, 0);
    }

    public List<RoomTile> getTilesAround(RoomTile tile, int directionOffset)
    {
        List<RoomTile> tiles = new ArrayList<>(8);

        if (tile != null)
        {
            for (int i = 0; i < 8; i++)
            {
                RoomTile t = this.getTileInFront(tile, (i + directionOffset) % 8);
                if (t != null)
                {
                    tiles.add(t);
                }
            }
        }

        return tiles;
    }

    public List<RoomTile> getWalkableTilesAround(RoomTile tile) {
        return getWalkableTilesAround(tile, 0);
    }

    public List<RoomTile> getWalkableTilesAround(RoomTile tile, int directionOffset) {
        List<RoomTile> availableTiles = new ArrayList<>(this.getTilesAround(tile, directionOffset));

        List<RoomTile> toRemove = new ArrayList<>();

        for(RoomTile t : availableTiles) {
            if(t == null || t.state != RoomTileState.OPEN || !t.isWalkable()) {
                toRemove.add(t);
            }
        }

        for(RoomTile t : toRemove) {
            availableTiles.remove(t);
        }

        return availableTiles;
    }

    public static Rectangle getRectangle(int x, int y, int width, int length, int rotation)
    {
        rotation = (rotation % 8);

        if(rotation == 2 || rotation == 6)
        {
            return new Rectangle(x, y, length, width);
        }

        return new Rectangle(x, y, width, length);
    }

    public boolean fitsOnMap(RoomTile tile, int width, int length, int rotation)
    {
        THashSet<RoomTile> pointList = new THashSet<>(width * length, 0.1f);

        if (tile != null)
        {
            if (rotation == 0 || rotation == 4)
            {
                for (short i = tile.x; i <= (tile.x + (width - 1)); i++)
                {
                    for (short j = tile.y; j <= (tile.y + (length - 1)); j++)
                    {
                        RoomTile t = this.getTile(i, j);

                        if (t == null || t.state == RoomTileState.INVALID)
                        {
                            return false;
                        }
                    }
                }
            }
            else if (rotation == 2 || rotation == 6)
            {
                for (short i = tile.x; i <= (tile.x + (length - 1)); i++)
                {
                    for (short j = tile.y; j <= (tile.y + (width - 1)); j++)
                    {
                        RoomTile t = this.getTile(i, j);

                        if (t == null || t.state == RoomTileState.INVALID)
                        {
                            return false;
                        }
                    }
                }
            }
        }

        return true;
    }

    public THashSet<RoomTile> getTilesAt(RoomTile tile, int width, int length, int rotation)
    {
        THashSet<RoomTile> pointList = new THashSet<>(width * length, 0.1f);

        if (tile != null)
        {
            if (rotation == 0 || rotation == 4)
            {
                for (short i = tile.x; i <= (tile.x + (width - 1)); i++)
                {
                    for (short j = tile.y; j <= (tile.y + (length - 1)); j++)
                    {
                        RoomTile t = this.getTile(i, j);

                        if (t != null)
                        {
                            pointList.add(t);
                        }
                    }
                }
            }
            else if (rotation == 2 || rotation == 6)
            {
                for (short i = tile.x; i <= (tile.x + (length - 1)); i++)
                {
                    for (short j = tile.y; j <= (tile.y + (width - 1)); j++)
                    {
                        RoomTile t = this.getTile(i, j);

                        if (t != null)
                        {
                            pointList.add(t);
                        }
                    }
                }
            }
        }

        return pointList;
    }

    public static boolean tilesAdjecent(RoomTile tile, RoomTile comparator, int width, int length, int rotation)
    {
        Rectangle rectangle = getRectangle(comparator.x, comparator.y, width, length, rotation);
        rectangle = new Rectangle(rectangle.x - 1, rectangle.y -1, rectangle.width + 2, rectangle.height + 2);

        return rectangle.contains(tile.x, tile.y);
    }
}