Region.java

package com.osroyale.game.world.region;
 
import com.osroyale.game.world.Interactable;
import com.osroyale.game.world.entity.mob.npc.Npc;
import com.osroyale.game.world.entity.mob.player.Player;
import com.osroyale.game.world.items.ground.GroundItem;
import com.osroyale.game.world.object.GameObject;
import com.osroyale.game.world.pathfinding.TraversalMap;
import com.osroyale.game.world.position.Position;
import com.osroyale.util.Utility;
 
import java.util.*;
 
import static com.osroyale.game.world.position.Position.HEIGHT_LEVELS;

 
public class Region {
    private static final int CHUNK_SIZE = 8;
    public static final int SIZE = CHUNK_SIZE * 8;
    public static final int VIEW_DISTANCE = SIZE / 4 - 1;
    public static final Map<Position, GameObject> ACTIVE_OBJECT = new HashMap<>();
    public static final Set<Position> SKIPPED_OBJECTS = new HashSet<>();

    private int id;

    private int x, y;

    private final RegionBlock[] blocks = new RegionBlock[HEIGHT_LEVELS];

    private Optional<Region[]> surroundingRegions = Optional.empty();

    public Region(int x, int y) {
        this.x = x;
        this.y = y;
        this.id = ((x >> 6) << 8) + (y >> 6);
    }

    public int getX() {
        return x;
    }

    public int getY() {
        return y;
    }

    public int getFlags(int height, int x, int y) {
        return getBlock(height).getFlags(x, y);
    }

    public void setFlags(int height, int x, int y, int flags) {
        getBlock(height).setFlags(x, y, flags);
    }

    public void unsetFlags(int height, int x, int y, int flags) {
        getBlock(height).unsetFlags(x, y, flags);
    }
 
    public Optional<Region[]> getSurroundingRegions() {
        return surroundingRegions;
    }
 
    public void setSurroundingRegions(Optional<Region[]> surroundingRegions) {
        this.surroundingRegions = surroundingRegions;
    }

    public Collection<Player> getPlayers(int height) {
        return getBlock(height).getPlayers();
    }

    public Collection<Npc> getNpcs(int height) {
        return getBlock(height).getNpcs();
    }

    public GroundItem getGroundItem(int id, Position position) {
        return getBlock(position.getHeight()).getGroundItem(id, position);
    }

    public void addPlayer(Player player) {
        getBlock(player.getHeight()).addPlayer(player);
    }

    public void removePlayer(Player player) {
        getBlock(player.getHeight()).removePlayer(player);
    }

    public void addNpc(Npc npc) {
        getBlock(npc.getHeight()).addNpc(npc);
    }

    public void removeNpc(Npc npc) {
        getBlock(npc.getHeight()).removeNpc(npc);
    }

    public void addObject(GameObject object) {
        getBlock(object.getHeight()).addObject(object);
    }

    public void removeObject(GameObject object) {
        getBlock(object.getHeight()).removeObject(object);
    }

    public void addGroundItem(GroundItem item) {
        getBlock(item.getHeight()).addGroundItem(item);
    }

    public void removeGroundItem(GroundItem item) {
        getBlock(item.getHeight()).removeGroundItem(item);
    }
 
    public boolean containsNpc(int height, Npc npc) {
        return getBlock(height).containsNpc(npc);
    }
 
    public boolean containsPlayer(int height, Player player) {
        return getBlock(height).containsPlayer(player);
    }

    public boolean containsObject(int height, GameObject object) {
        return getBlock(height).containsObject(object);
    }

    public boolean containsObject(Position position) {
        return getBlock(position.getHeight()).containsObject(position);
    }

    public Set<GroundItem> getGroundItems(Position position) {
        return getBlock(position.getHeight()).getGroundItems(position);
    }

    public GameObject getGameObject(int id, Position position) {
        return getBlock(position.getHeight()).getGameObject(id, position);
    }
 
    public GameObject getCustomObject(int id, Position position) {
        return getBlock(position.getHeight()).getCustomObject(id, position);
    }
 
    public List<GameObject> getObjects(Position position) {
        return getBlock(position.getHeight()).getGameObjects(position);
    }

    public void sendGroundItems(Player player) {
        getBlock(player.getHeight()).sendGroundItems(player);
    }

    public void sendGameObjects(Player player) {
        getBlock(player.getHeight()).sendGameObjects(player);
    }

    public boolean contains(Position position) {
        return getX() == position.getRegionX() && getY() == position.getRegionY();
    }

    public boolean contains(int x, int y) {
        return getX() == ((x >> 3) - 6) >> 3 && getY() == ((y >> 3) - 6) >> 3;
    }
 
    private RegionBlock getBlock(int height) {
        if (height > HEIGHT_LEVELS || height < 0) {
            throw new IllegalArgumentException("Height is out of bounds. Received (" + height + "), expected range [0, " + HEIGHT_LEVELS + "].");
        }
 
        if (blocks[height] == null) {
            blocks[height] = new RegionBlock();
        }
 
        return blocks[height];
    }
 
    public static boolean reachable(Interactable source, Interactable target) {
        return reachable(source.getPosition(), source.width(), source.length(), target.getPosition(), target.width(), target.length());
    }
 
    public static boolean reachable(Position source, int sourceWidth, int sourceLength, Position target, int targetWidth, int targetLength) {
        if (Utility.inside(source, sourceWidth, sourceLength, target, targetWidth, targetLength)) {
            return targetWidth == 0 || targetLength == 0;
        }
 
        int x, y;
        int sourceTopX = source.getX() + sourceWidth - 1;
        int sourceTopY = source.getY() + sourceLength - 1;
        int targetTopX = target.getX() + targetWidth - 1;
        int targetTopY = target.getY() + targetLength - 1;
 
        if (sourceTopY == target.getY() - 1 && source.getX() >= target.getX() && source.getX() <= targetTopX) {
            for (x = 0, y = sourceLength - 1; x < sourceWidth; x++)
                if (TraversalMap.blockedNorth(source.transform(x, y)))
                    return false;
            return true;
        }
 
        if (sourceTopX == target.getX() - 1 && source.getY() >= target.getY() && source.getY() <= targetTopY) {
            for (x = 0, y = 0; y < sourceLength; y++)
                if (TraversalMap.blockedEast(source.transform(x, y)))
                    return false;
            return true;
        }
 
        if (source.getY() == targetTopY + 1 && source.getX() >= target.getX() && source.getX() <= targetTopX) {
            for (x = 0, y = 0; x < sourceWidth; x++)
                if (TraversalMap.blockedSouth(source.transform(x, y)))
                    return false;
            return true;
        }
 
        if (source.getX() == targetTopX + 1 && source.getY() >= target.getY() && source.getY() <= targetTopY) {
            for (x = sourceWidth - 1, y = 0; y < sourceLength; y++)
                if (TraversalMap.blockedWest(source.transform(x, y)))
                    return false;
            return true;
        }
 
        return false;
    }
 
    public void skip(GameObject gameObject) {
        getBlock(gameObject.getHeight()).skip(gameObject);
    }
 
    @Override
    public String toString() {
        return "Region[" + x + "_" + y + "]";
    }
 
    public int getId() {
        return id;
    }
 
}