WanderWaypointProvider.java

package net.citizensnpcs.trait.waypoint;

import java.util.Collection;
import java.util.Iterator;
import java.util.List;

import org.bukkit.Bukkit;
import org.bukkit.Location;
import org.bukkit.block.Block;
import org.bukkit.block.BlockFace;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Entity;
import org.bukkit.event.EventHandler;
import org.bukkit.event.block.Action;
import org.bukkit.event.player.AsyncPlayerChatEvent;
import org.bukkit.event.player.PlayerInteractEntityEvent;
import org.bukkit.event.player.PlayerInteractEvent;
import org.bukkit.metadata.FixedMetadataValue;

import com.google.common.base.Function;
import com.google.common.base.Supplier;
import com.google.common.collect.ForwardingList;
import com.google.common.collect.Lists;
import com.sk89q.worldedit.bukkit.BukkitAdapter;
import com.sk89q.worldguard.WorldGuard;
import com.sk89q.worldguard.protection.managers.RegionManager;

import ch.ethz.globis.phtree.PhTreeSolid;
import net.citizensnpcs.api.CitizensAPI;
import net.citizensnpcs.api.ai.GoalController.GoalEntry;
import net.citizensnpcs.api.ai.goals.WanderGoal;
import net.citizensnpcs.api.astar.pathfinder.MinecraftBlockExaminer;
import net.citizensnpcs.api.command.CommandContext;
import net.citizensnpcs.api.npc.NPC;
import net.citizensnpcs.api.persistence.Persist;
import net.citizensnpcs.api.util.DataKey;
import net.citizensnpcs.api.util.Messaging;
import net.citizensnpcs.util.Messages;
import net.citizensnpcs.util.Util;

/**
 * A wandering waypoint provider that wanders between either a box centered at the current location or inside a region
 * defined by a list of boxes.
 */
public class WanderWaypointProvider
        implements WaypointProvider, Supplier<PhTreeSolid<Boolean>>, Function<NPC, Location> {
    private WanderGoal currentGoal;
    @Persist
    public int delay = -1;
    private NPC npc;
    @Persist
    public boolean pathfind = true;
    private boolean paused;
    @Persist
    private final List<Location> regionCentres = Lists.newArrayList();
    private PhTreeSolid<Boolean> tree = PhTreeSolid.create(3);
    @Persist
    private String worldguardRegion;
    private Object worldguardRegionCache;
    @Persist
    public int xrange = DEFAULT_XRANGE;
    @Persist
    public int yrange = DEFAULT_YRANGE;

    public void addRegionCentre(Location centre) {
        regionCentres.add(centre);
        recalculateTree();
    }

    public void addRegionCentres(Collection<Location> centre) {
        regionCentres.addAll(centre);
        recalculateTree();
    }

    @Override
    public Location apply(NPC npc) {
        Location closestCentre = null;
        double minDist = Double.MAX_VALUE;
        for (Location centre : regionCentres) {
            double d = centre.distanceSquared(npc.getStoredLocation());
            if (d < minDist) {
                minDist = d;
                closestCentre = centre;
            }
        }
        if (closestCentre != null) {
            Location randomLocation = MinecraftBlockExaminer.findRandomValidLocation(npc.getEntity().getLocation(),
                    xrange, yrange, new Function<Block, Boolean>() {
                        @Override
                        public Boolean apply(Block block) {
                            if ((block.getRelative(BlockFace.UP).isLiquid() || block.getRelative(0, 2, 0).isLiquid())
                                    && npc.getNavigator().getDefaultParameters().avoidWater()) {
                                return false;
                            }
                            return true;
                        }
                    }, Util.getFastRandom());
            if (randomLocation != null) {
                return randomLocation;
            }
            // TODO: should find closest edge block that is valid
            return MinecraftBlockExaminer.findValidLocation(closestCentre, xrange, yrange);
        }
        return null;
    }

    @Override
    public WaypointEditor createEditor(final CommandSender sender, CommandContext args) {
        return new WaypointEditor() {
            boolean editingRegions = false;
            EntityMarkers<Location> markers = new EntityMarkers<Location>();

            @Override
            public void begin() {
                Messaging.sendTr(sender, Messages.WANDER_WAYPOINTS_BEGIN, pathfind ? "<green>" : "<red>");
                setPaused(true);
            }

            @Override
            public void end() {
                Messaging.sendTr(sender, Messages.WANDER_WAYPOINTS_END);
                editingRegions = false;
                setPaused(false);
                markers.destroyMarkers();
            }

            private String formatLoc(Location location) {
                return String.format("[[%d]], [[%d]], [[%d]]", location.getBlockX(), location.getBlockY(),
                        location.getBlockZ());
            }

            @EventHandler(ignoreCancelled = true)
            public void onPlayerChat(AsyncPlayerChatEvent event) {
                if (!event.getPlayer().equals(sender))
                    return;
                String message = event.getMessage().toLowerCase();
                if (message.startsWith("xrange") || message.startsWith("yrange")) {
                    event.setCancelled(true);
                    int range = 0;
                    try {
                        range = Integer.parseInt(message.split(" ", 2)[1]);
                        if (range <= 0) {
                            range = 0;
                        }
                        if (message.startsWith("xrange")) {
                            xrange = range;
                        } else {
                            yrange = range;
                        }
                        if (currentGoal != null) {
                            currentGoal.setXYRange(xrange, yrange);
                        }
                        recalculateTree();
                    } catch (Exception ex) {
                    }
                    Bukkit.getScheduler().scheduleSyncDelayedTask(CitizensAPI.getPlugin(),
                            () -> Messaging.sendTr(sender, Messages.WANDER_WAYPOINTS_RANGE_SET, xrange, yrange));
                } else if (message.startsWith("regions")) {
                    event.setCancelled(true);
                    editingRegions = !editingRegions;
                    Bukkit.getScheduler().scheduleSyncDelayedTask(CitizensAPI.getPlugin(), () -> {
                        if (editingRegions) {
                            for (Location regionCentre : regionCentres) {
                                Entity entity = markers.createMarker(regionCentre, regionCentre);
                                entity.setMetadata("wandermarker",
                                        new FixedMetadataValue(CitizensAPI.getPlugin(), regionCentre));
                            }
                            Messaging.sendTr(sender, Messages.WANDER_WAYPOINTS_REGION_EDITING_START);
                        } else {
                            markers.destroyMarkers();
                            Messaging.sendTr(sender, Messages.WANDER_WAYPOINTS_REGION_EDITING_STOP);
                        }
                    });
                } else if (message.startsWith("delay")) {
                    event.setCancelled(true);
                    try {
                        delay = Integer.parseInt(message.split(" ")[1]);
                        if (currentGoal != null) {
                            currentGoal.setDelay(delay);
                        }
                        Bukkit.getScheduler().scheduleSyncDelayedTask(CitizensAPI.getPlugin(),
                                () -> Messaging.sendTr(sender, Messages.WANDER_WAYPOINTS_DELAY_SET, delay));
                    } catch (Exception e) {
                        Bukkit.getScheduler().scheduleSyncDelayedTask(CitizensAPI.getPlugin(),
                                () -> Messaging.sendErrorTr(sender, Messages.WANDER_WAYPOINTS_INVALID_DELAY));
                    }
                } else if (message.startsWith("worldguardregion")) {
                    event.setCancelled(true);
                    Bukkit.getScheduler().scheduleSyncDelayedTask(CitizensAPI.getPlugin(), () -> {
                        Object region = null;
                        String regionId = message.replace("worldguardregion ", "");
                        try {
                            RegionManager manager = WorldGuard.getInstance().getPlatform().getRegionContainer()
                                    .get(BukkitAdapter.adapt(npc.getStoredLocation().getWorld()));
                            region = manager.getRegion(regionId);
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                        if (region == null) {
                            Messaging.sendErrorTr(sender, Messages.WANDER_WAYPOINTS_WORLDGUARD_REGION_NOT_FOUND);
                            return;
                        }
                        WanderWaypointProvider.this.worldguardRegion = regionId;
                        if (currentGoal != null) {
                            currentGoal.setWorldGuardRegion(region);
                        }
                        Messaging.sendErrorTr(sender, Messages.WANDER_WAYPOINTS_WORLDGUARD_REGION_SET, regionId);
                    });
                } else if (message.startsWith("pathfind")) {
                    event.setCancelled(true);
                    Bukkit.getScheduler().scheduleSyncDelayedTask(CitizensAPI.getPlugin(), () -> {
                        pathfind = !pathfind;
                        if (currentGoal != null) {
                            currentGoal.setPathfind(pathfind);
                        }
                        begin();
                    });
                }
            }

            @EventHandler(ignoreCancelled = true)
            public void onPlayerInteract(PlayerInteractEvent event) {
                if (!event.getPlayer().equals(sender) || event.getAction() == Action.PHYSICAL || !npc.isSpawned()
                        || !editingRegions || event.getPlayer().getWorld() != npc.getEntity().getWorld()
                        || Util.isOffHand(event))
                    return;
                if (event.getAction() == Action.LEFT_CLICK_BLOCK || event.getAction() == Action.LEFT_CLICK_AIR) {
                    if (event.getClickedBlock() == null)
                        return;
                    event.setCancelled(true);
                    Location at = event.getClickedBlock().getLocation().add(0, 1, 0);
                    if (!regionCentres.contains(at)) {
                        regionCentres.add(at);
                        Entity entity = markers.createMarker(at, at);
                        entity.setMetadata("wandermarker", new FixedMetadataValue(CitizensAPI.getPlugin(), at));
                        Messaging.sendTr(sender, Messages.WANDER_WAYPOINTS_ADDED_REGION, formatLoc(at),
                                regionCentres.size());
                        recalculateTree();
                    }
                }
            }

            @EventHandler(ignoreCancelled = true)
            public void onPlayerInteractEntity(PlayerInteractEntityEvent event) {
                if (!sender.equals(event.getPlayer()) || !editingRegions || Util.isOffHand(event))
                    return;
                if (!event.getRightClicked().hasMetadata("wandermarker"))
                    return;
                regionCentres.remove(event.getRightClicked().getMetadata("wandermarker").get(0).value());
                markers.removeMarker((Location) event.getRightClicked().getMetadata("wandermarker").get(0).value());
                Messaging.sendTr(sender, Messages.WANDER_WAYPOINTS_REMOVED_REGION,
                        formatLoc((Location) event.getRightClicked().getMetadata("wandermarker").get(0).value()),
                        regionCentres.size());
                recalculateTree();
            }

        };
    }

    @Override
    public PhTreeSolid<Boolean> get() {
        return regionCentres.isEmpty() ? null : tree;
    }

    public List<Location> getRegionCentres() {
        return new RecalculateList();
    }

    public Object getWorldGuardRegion() {
        if (worldguardRegion == null) {
            return null;
        }
        if (worldguardRegionCache != null) {
            return worldguardRegionCache;
        }
        try {
            RegionManager manager = WorldGuard.getInstance().getPlatform().getRegionContainer()
                    .get(BukkitAdapter.adapt(npc.getStoredLocation().getWorld()));
            return worldguardRegionCache = manager.getRegion(worldguardRegion);
        } catch (Throwable t) {
            t.printStackTrace();
            return null;
        }
    }

    @Override
    public boolean isPaused() {
        return paused;
    }

    @Override
    public void load(DataKey key) {
        recalculateTree();
    }

    @Override
    public void onRemove() {
        npc.getDefaultGoalController().removeGoal(currentGoal);
    }

    @Override
    public void onSpawn(NPC npc) {
        this.npc = npc;
        if (currentGoal == null) {
            currentGoal = WanderGoal.builder(npc).xrange(xrange).yrange(yrange).fallback(this).tree(this).delay(delay)
                    .worldguardRegion(getWorldGuardRegion()).build();
            if (paused) {
                currentGoal.pause();
            }
        }
        Iterator<GoalEntry> itr = npc.getDefaultGoalController().iterator();
        while (itr.hasNext()) {
            if (itr.next() instanceof WanderGoal) {
                itr.remove();
            }
        }
        npc.getDefaultGoalController().addGoal(currentGoal, 1);
    }

    private void recalculateTree() {
        tree.clear();
        tree = PhTreeSolid.create(3);
        for (Location loc : regionCentres) {
            long[] lower = { loc.getBlockX() - xrange, loc.getBlockY() - yrange, loc.getBlockZ() - xrange };
            long[] upper = { loc.getBlockX() + xrange, loc.getBlockY() + yrange, loc.getBlockZ() + xrange };
            tree.put(lower, upper, true);
        }
    }

    public void removeRegionCentre(Location centre) {
        regionCentres.remove(centre);
        recalculateTree();
    }

    public void removeRegionCentres(Collection<Location> centre) {
        regionCentres.removeAll(centre);
        recalculateTree();
    }

    @Override
    public void save(DataKey key) {
    }

    @Override
    public void setPaused(boolean paused) {
        this.paused = paused;
        if (currentGoal != null) {
            if (paused) {
                currentGoal.pause();
            } else {
                currentGoal.unpause();
            }
        }
    }

    public void setXYRange(int xrange, int yrange) {
        this.xrange = xrange;
        this.yrange = yrange;
        if (currentGoal != null) {
            currentGoal.setXYRange(xrange, yrange);
        }
    }

    private class RecalculateList extends ForwardingList<Location> {
        @Override
        public void add(int idx, Location loc) {
            super.add(idx, loc);
            recalculateTree();
        }

        @Override
        public boolean add(Location loc) {
            boolean val = super.add(loc);
            recalculateTree();
            return val;
        }

        @Override
        protected List<Location> delegate() {
            return regionCentres;
        }

        @Override
        public Location remove(int idx) {
            Location val = super.remove(idx);
            recalculateTree();
            return val;
        }

        @Override
        public Location set(int idx, Location idx2) {
            Location val = super.set(idx, idx2);
            recalculateTree();
            return val;
        }
    }

    private static final int DEFAULT_XRANGE = 25;
    private static final int DEFAULT_YRANGE = 3;
}