Update nearby endpoint - Add Nation target type, and better townblock checks

Author: Veyronity

docs/nearby.md

@@ -14,8 +14,9 @@ Example **POST** request with a nearby query based on a town
     {
       "target_type": "TOWN",
       "target": "Melbourne",
-      "search_type": "TOWN",
-      "radius": 100
+      "search_type": "TOWN", // Returns a list of towns within the specified radius
+      "radius": 100,
+      "strict": true // Optional field. Default is false. 
     }
   ]
 }
@@ -31,14 +32,17 @@ Example **POST** request with a nearby query based on coordinates
         2000,
         10000
       ],
-      "search_type": "TOWN",
+      "search_type": "NATION", // Returns a list of nations whose capitals fall within the specified radius
       "radius": 10000
     }
   ]
 }
 ```
 
-Example **POST** response for a nearby query with `search_type` set to `TOWN` (the only type currently available)
+Note: When checking if a town is in range, the distance between the center and the town's homeblock is checked. If the distance is smaller than the radius, the town is added to the response.  
+If it's out of range but only by <=300 blocks, and `strict` is set to false (or not specified), all the town's townblocks are checked
+
+Example **POST** response for a nearby query with `search_type` set to `TOWN`
 ```json5
 [
   [

src/main/java/net/earthmc/emcapi/endpoint/NearbyEndpoint.java

@@ -5,6 +5,7 @@
 import com.google.gson.JsonObject;
 import com.palmergames.bukkit.towny.TownyAPI;
 import com.palmergames.bukkit.towny.TownySettings;
+import com.palmergames.bukkit.towny.object.Nation;
 import com.palmergames.bukkit.towny.object.Town;
 import com.palmergames.bukkit.towny.object.TownBlock;
 import com.palmergames.bukkit.towny.object.WorldCoord;
@@ -23,6 +24,7 @@
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Objects;
 
 public class NearbyEndpoint extends PostEndpoint<NearbyContext> {
 
@@ -43,89 +45,139 @@ public NearbyContext getObjectOrNull(JsonElement element, @Nullable String key)
         NearbyType searchType;
         try {
             targetType = NearbyType.valueOf(targetTypeString);
+        } catch (IllegalArgumentException ignored) {
+            throw new BadRequestResponse("Invalid target type");
+        }
+        try {
             searchType = NearbyType.valueOf(searchTypeString);
-        } catch (IllegalArgumentException e) {
-            throw new BadRequestResponse("Your target or search type is invalid");
+            if (searchType == NearbyType.COORDINATE) {
+                throw new BadRequestResponse("Search type cannot be coordinate. Select town or nation.");
+            }
+        } catch (IllegalArgumentException ignored) {
+            throw new BadRequestResponse("Invalid search type");
         }
 
         Integer radius = JSONUtil.getJsonElementAsIntegerOrNull(jsonObject.get("radius"));
-        if (radius == null) throw new BadRequestResponse("You did not specify a radius");
+        if (radius == null || radius < 0) throw new BadRequestResponse("Invalid radius provided");
 
+        boolean strict = Objects.requireNonNullElse(JSONUtil.getJsonElementAsBooleanOrNull(jsonObject.get("strict")), false);
         JsonElement targetElement = jsonObject.get("target");
-        if (targetType.equals(NearbyType.COORDINATE)) {
-            JsonArray jsonArray = JSONUtil.getJsonElementAsJsonArrayOrNull(targetElement);
-            if (jsonArray == null) throw new BadRequestResponse("Your target is not a valid JSON array");
-
-            Pair<Integer, Integer> pair = new Pair<>(jsonArray.get(0).getAsInt(), jsonArray.get(1).getAsInt());
+        return switch (targetType) {
+            case COORDINATE -> {
+                JsonArray jsonArray = JSONUtil.getJsonElementAsJsonArrayOrNull(targetElement);
+                if (jsonArray == null) throw new BadRequestResponse("Your target is not a valid JSON array");
 
-            return new NearbyContext(targetType, pair, searchType, radius);
-        } else if (targetType.equals(NearbyType.TOWN)) {
-            String target = JSONUtil.getJsonElementAsStringOrNull(targetElement);
-            if (target == null) throw new BadRequestResponse("Your target is not a valid string");
+                Pair<Integer, Integer> pair = new Pair<>(jsonArray.get(0).getAsInt(), jsonArray.get(1).getAsInt());
 
-            return new NearbyContext(targetType, target, searchType, radius);
-        }
+                yield new NearbyContext(targetType, pair, searchType, radius, strict);
+            }
+            case TOWN, NATION -> {
+                String target = JSONUtil.getJsonElementAsStringOrNull(targetElement);
+                if (target == null) throw new BadRequestResponse("Your target is not a valid string");
 
-        return null;
+                yield new NearbyContext(targetType, target, searchType, radius, strict);
+            }
+        };
     }
 
     @Override
     public JsonElement getJsonElement(NearbyContext context, @Nullable String key) {
         NearbyType targetType = context.getTargetType();
         int radius = context.getRadius();
-        switch (targetType) {
+        NearbyType searchType = context.getSearchType();
+        boolean strict = context.isStrict();
+
+        return switch (targetType) {
             case COORDINATE -> {
                 Pair<Integer, Integer> pair = context.getTargetCoordinate();
 
-                return lookupNearbyCoordinate(pair.getFirst(), pair.getSecond(), radius);
-            }
-            case TOWN -> {
-                String townName = context.getTargetString();
-
-                return lookupNearbyTown(townName, radius);
+                yield lookupNearCoordinates(pair.getFirst(), pair.getSecond(), radius, strict, searchType);
             }
+            case TOWN -> lookupNearTown(context.getTargetString(), radius, strict, searchType);
+            case NATION -> lookupNearNation(context.getTargetString(), radius, strict, searchType);
         };
-
-        return null;
     }
 
-    public JsonArray lookupNearbyCoordinate(Integer x, Integer z, Integer radius) {
-        if (x == null || z == null) throw new BadRequestResponse("Invalid coordinates provided");
-        if (radius == null || radius < 0) throw new BadRequestResponse("Invalid radius provided");
-
-        Location location = new Location(Bukkit.getWorlds().get(0), x, 0, z);
+    private JsonArray lookupNearCoordinates(int x, int z, int radius, boolean strict,  NearbyType searchType) {
+        Location location = new Location(Bukkit.getWorlds().getFirst(), x, 0, z);
 
-        return getJsonArrayOfNearbyTowns(WorldCoord.parseWorldCoord(location), radius, null);
+        WorldCoord worldCoord = WorldCoord.parseWorldCoord(location);
+        return searchType == NearbyType.TOWN ? getJsonArrayOfNearbyTowns(worldCoord, radius, strict, null) : getNearbyNations(worldCoord, radius, strict, null);
     }
 
-    public JsonElement lookupNearbyTown(String townString, Integer radius) {
+    private JsonElement lookupNearTown(String townString, int radius, boolean strict, NearbyType searchType) {
         if (townString == null) throw new BadRequestResponse("Invalid town provided");
 
         Town town = TownyAPI.getInstance().getTown(townString);
         if (town == null) throw new BadRequestResponse(townString + " is not a real town");
 
-        if (radius == null || radius < 0) throw new BadRequestResponse("Invalid radius provided");
-
         TownBlock homeBlock = town.getHomeBlockOrNull();
         if (homeBlock == null) throw new BadRequestResponse("The specified town has no homeblock");
 
-        return getJsonArrayOfNearbyTowns(homeBlock.getWorldCoord(), radius, town);
+        return searchType == NearbyType.TOWN ? getJsonArrayOfNearbyTowns(homeBlock.getWorldCoord(), radius, strict, town) : getNearbyNations(homeBlock.getWorldCoord(), radius, strict, town.isCapital() ? town.getNationOrNull() : null);
     }
 
-    private JsonArray getJsonArrayOfNearbyTowns(WorldCoord worldCoord, int radius, Town town) {
-        List<Town> towns = new ArrayList<>();
+    private JsonElement lookupNearNation(String nationName, int radius, boolean strict, NearbyType searchType) {
+        if (nationName == null) throw new BadRequestResponse("Invalid nation provided");
 
-        for (Town otherTown : TownyAPI.getInstance().getTowns()) {
-            if (town != null && town == otherTown) continue; // Don't add the town we are looking nearby
+        Nation nation = TownyAPI.getInstance().getNation(nationName);
+        if (nation == null) throw new BadRequestResponse(nationName + " is not a real nation");
 
-            TownBlock homeBlock = otherTown.getHomeBlockOrNull();
-            if (homeBlock == null) continue;
+        Town capital = nation.getCapital();
+        if (capital == null) throw new BadRequestResponse("The specified nation has no capital");
 
-            WorldCoord homeBlockWorldCoord = homeBlock.getWorldCoord();
+        TownBlock homeBlock = capital.getHomeBlockOrNull();
+        if (homeBlock == null) throw new BadRequestResponse("The specified nation's capital has no homeblock");
 
-            if (MathUtil.distance(worldCoord, homeBlockWorldCoord) * TownySettings.getTownBlockSize() <= radius) towns.add(otherTown);
+        return searchType == NearbyType.TOWN ? getJsonArrayOfNearbyTowns(homeBlock.getWorldCoord(), radius, strict, capital) : getNearbyNations(homeBlock.getWorldCoord(), radius, strict, nation);
+    }
+
+    private JsonArray getJsonArrayOfNearbyTowns(WorldCoord center, int radius, boolean strict, Town excludeTown) {
+        List<Town> towns = new ArrayList<>();
+
+        for (Town town : TownyAPI.getInstance().getTowns()) {
+            if (excludeTown != null && excludeTown.equals(town)) continue;
+
+            if (isTownInRange(town, center, radius, strict)) {
+                towns.add(town);
+            }
         }
 
         return EndpointUtils.getTownArray(towns);
     }
+
+    private JsonArray getNearbyNations(WorldCoord center, int radius, boolean strict, Nation excludeNation) {
+        List<Nation> nations = new ArrayList<>();
+
+        for (Nation nation : TownyAPI.getInstance().getNations()) {
+            if (excludeNation != null && excludeNation.equals(nation)) continue;
+
+            Town capital = nation.getCapital();
+            if (capital == null) continue;
+
+            if (isTownInRange(capital, center, radius, strict)) {
+                nations.add(nation);
+            }
+        }
+
+        return EndpointUtils.getNationArray(nations);
+    }
+
+    private boolean isTownInRange(Town town, WorldCoord center, int radius, boolean strict) {
+        TownBlock homeBlock = town.getHomeBlockOrNull();
+        if (homeBlock == null) return false;
+        WorldCoord homeBlockWorldCoord = homeBlock.getWorldCoord();
+        double distance = MathUtil.distance(center, homeBlockWorldCoord) * TownySettings.getTownBlockSize();
+        if (distance <= radius) {
+            return true;
+        }
+        if (!strict && distance <= radius + 300) { // Homeblock is less than 300 blocks out of reach, check all the town's chunks
+            for (TownBlock townBlock : town.getTownBlocks()) {
+                if (MathUtil.distance(center, townBlock.getWorldCoord()) * TownySettings.getTownBlockSize() <= radius) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
 }

src/main/java/net/earthmc/emcapi/object/nearby/NearbyContext.java

@@ -9,21 +9,24 @@ public class NearbyContext {
     private final Pair<Integer, Integer> targetCoordinate;
     private final NearbyType searchType;
     private final int radius;
+    private final boolean strict;
 
-    public NearbyContext(NearbyType targetType, String target, NearbyType searchType, int radius) {
+    public NearbyContext(NearbyType targetType, String target, NearbyType searchType, int radius, boolean strict) {
         this.targetType = targetType;
         this.targetString = target;
         this.targetCoordinate = null;
         this.searchType = searchType;
         this.radius = radius;
+        this.strict = strict;
     }
 
-    public NearbyContext(NearbyType targetType, Pair<Integer, Integer> targetCoordinate, NearbyType searchType, int radius) {
+    public NearbyContext(NearbyType targetType, Pair<Integer, Integer> targetCoordinate, NearbyType searchType, int radius, boolean strict) {
         this.targetType = targetType;
         this.targetString = null;
         this.targetCoordinate = targetCoordinate;
         this.searchType = searchType;
         this.radius = radius;
+        this.strict = strict;
     }
 
     public NearbyType getTargetType() {
@@ -45,4 +48,8 @@ public NearbyType getSearchType() {
     public int getRadius() {
         return radius;
     }
+
+    public boolean isStrict() {
+        return strict;
+    }
 }

src/main/java/net/earthmc/emcapi/object/nearby/NearbyType.java

@@ -5,5 +5,6 @@
  */
 public enum NearbyType {
     COORDINATE,
-    TOWN
+    TOWN,
+    NATION
 }

src/main/java/net/earthmc/emcapi/util/JSONUtil.java

@@ -40,6 +40,17 @@ public static Integer getJsonElementAsIntegerOrNull(JsonElement element) {
         return primitive.getAsInt();
     }
 
+    public static Boolean getJsonElementAsBooleanOrNull(JsonElement element) {
+        if (element == null) return null;
+
+        if (!element.isJsonPrimitive()) return null;
+
+        JsonPrimitive primitive = element.getAsJsonPrimitive();
+        if (!primitive.isBoolean()) return null;
+
+        return primitive.getAsBoolean();
+    }
+
     public static JsonArray getJsonElementAsJsonArrayOrNull(JsonElement element) {
         if (element == null) return null;