RegionBlock.java

package com.osroyale.game.world.region;
 
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.CustomGameObject;
import com.osroyale.game.world.object.GameObject;
import com.osroyale.game.world.position.Position;
import com.osroyale.net.packet.out.SendAddObject;
import com.osroyale.net.packet.out.SendGroundItem;
import com.osroyale.net.packet.out.SendRemoveObject;
 
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentLinkedDeque;
 
import static com.osroyale.game.world.region.Region.SIZE;

 
public class RegionBlock {

    private int[] flags;

    private Deque<Player> players = new ConcurrentLinkedDeque<>();

    private Deque<Npc> npcs = new ConcurrentLinkedDeque<>();

    private Map<Position, List<GameObject>> objects;

    private Deque<GameObject> skipped;

    private Map<Position, Set<GroundItem>> groundItems;

    public Collection<Player> getPlayers() {
        return players;
    }

    public Collection<Npc> getNpcs() {
        return npcs;
    }

    public Set<GroundItem> getGroundItems(Position position) {
        return getGroundItems().getOrDefault(position, ConcurrentHashMap.newKeySet());
    }

    GroundItem getGroundItem(int id, Position position) {
        for (GroundItem item : getGroundItems(position)) {
            if (item.isRegistered() && item.item.matchesId(id)) {
                return item;
            }
        }
        return null;
    }

    void addPlayer(Player player) {
        players.add(player);
    }

    void removePlayer(Player player) {
        players.remove(player);
    }

    void addNpc(Npc npc) {
        npcs.add(npc);
    }

    void removeNpc(Npc npc) {
        npcs.remove(npc);
    }

    void addObject(GameObject object) {
        List<GameObject> objs = getObjects().getOrDefault(object.getPosition(), new LinkedList<>());
        if (objs.add(object))
            getObjects().put(object.getPosition(), objs);
    }

    void removeObject(GameObject object) {
        List<GameObject> objs = getObjects().get(object.getPosition());
        if (objs != null)
            objs.remove(object);
    }

    void addGroundItem(GroundItem item) {
        Set<GroundItem> items = getGroundItems(item.getPosition());
        int index = 0;
        for (GroundItem other : items) {
            if (other.getIndex() + 1 > index) {
                index = other.getIndex() + 1;
            }
        }
        item.setIndex(index);
        items.add(item);
        getGroundItems().put(item.getPosition(), items);
    }

    void removeGroundItem(GroundItem item) {
        Set<GroundItem> items = getGroundItems(item.getPosition());
        items.remove(item);
        if (items.isEmpty()) {
            getGroundItems().remove(item.getPosition());
        } else {
            getGroundItems().put(item.getPosition(), items);
        }
    }

    boolean containsNpc(Npc npc) {
        return npcs.contains(npc);
    }

    boolean containsPlayer(Player player) {
        return players.contains(player);
    }

    boolean containsObject(GameObject object) {
        List<GameObject> objs = getObjects().get(object.getPosition());
        return objs != null && objs.contains(object);
    }

    boolean containsObject(Position position) {
        List<GameObject> objs = getObjects().get(position);
        return objs != null && !objs.isEmpty();
    }
 
    GameObject getGameObject(int id, Position position) {
        for (GameObject object : getGameObjects(position)) {
            if (object.getId() == id) {
                return object;
            }
        }
        return null;
    }
 
    GameObject getCustomObject(int id, Position position) {
        Set<Map.Entry<Position, List<GameObject>>> entrySet = getObjects().entrySet();
        for (Map.Entry<Position, List<GameObject>> entry : entrySet) {
            for (GameObject object : entry.getValue()) {
                if (!(object instanceof CustomGameObject))
                    continue;
                CustomGameObject obj = (CustomGameObject) object;
                if (!obj.isValid()) {
                    continue;
                }
                System.err.println("haha we got it " + obj.getId());
                return obj;
            }
        }
        return null;
    }
 
    List<GameObject> getGameObjects(Position position) {
        return getObjects().getOrDefault(position, Collections.emptyList());
    }
 
    void sendGameObjects(Player player) {
        for (GameObject object : getRemovedObjects()) {
            player.send(new SendRemoveObject(object));
        }
        Set<Map.Entry<Position, List<GameObject>>> entrySet = getObjects().entrySet();
        for (Map.Entry<Position, List<GameObject>> entry : entrySet) {
            for (GameObject object : entry.getValue()) {
                if (!(object instanceof CustomGameObject))
                    continue;
                CustomGameObject obj = (CustomGameObject) object;
                if (!obj.isValid())
                    continue;
                player.send(new SendAddObject(obj));
            }
        }
    }

    void sendGroundItems(Player player) {
        for (Map.Entry<Position, Set<GroundItem>> entry : getGroundItems().entrySet()) {
            for (GroundItem groundItem : entry.getValue()) {
                if (!groundItem.isRegistered())
                    continue;
 
                if (!groundItem.canSee(player))
                    continue;
 
                player.send(new SendGroundItem(groundItem));
            }
        }
    }
 
    private Map<Position, Set<GroundItem>> getGroundItems() {
        if (groundItems == null)
            groundItems = new ConcurrentHashMap<>();
        return groundItems;
    }
 
    private Map<Position, List<GameObject>> getObjects() {
        if (objects == null)
            objects = new ConcurrentHashMap<>();
        return objects;
    }
 
    private Deque<GameObject> getRemovedObjects() {
        if (skipped == null)
            skipped = new ConcurrentLinkedDeque<>();
        return skipped;
    }

    int getFlags(int x, int y) {
        if (flags == null)
            flags = new int[SIZE * SIZE];
        return flags[x + y * SIZE];
    }

    void setFlags(int x, int y, int flag) {
        if (flags == null)
            flags = new int[SIZE * SIZE];
        flags[x + y * SIZE] |= flag;
    }

    void unsetFlags(int x, int y, int flag) {
        if (flags == null)
            flags = new int[SIZE * SIZE];
        flags[x + y * SIZE] &= ~flag;
    }
 
    void skip(GameObject gameObject) {
        getRemovedObjects().add(gameObject);
    }
}