Update docs for new extensions, fix errors, add villager trade API

Author: Omena0

releases/pyjavabridge-dev.jar

@@ -1110,6 +1110,71 @@ private List<Object> preprocessTeleportArgs(Entity entity, List<Object> args) {
         return args;
     }
 
+    private Map<String, Object> serializeMerchantRecipe(org.bukkit.inventory.MerchantRecipe recipe) {
+        Map<String, Object> map = new java.util.LinkedHashMap<>();
+        map.put("result", recipe.getResult().serialize());
+        List<Map<String, Object>> ingredients = new ArrayList<>();
+        for (ItemStack ingredient : recipe.getIngredients()) {
+            ingredients.add(ingredient.serialize());
+        }
+        map.put("ingredients", ingredients);
+        map.put("maxUses", recipe.getMaxUses());
+        map.put("uses", recipe.getUses());
+        map.put("experienceReward", recipe.hasExperienceReward());
+        map.put("villagerExperience", recipe.getVillagerExperience());
+        map.put("priceMultiplier", recipe.getPriceMultiplier());
+        map.put("demand", recipe.getDemand());
+        map.put("specialPrice", recipe.getSpecialPrice());
+        return map;
+    }
+
+    @SuppressWarnings("unchecked")
+    private org.bukkit.inventory.MerchantRecipe deserializeMerchantRecipe(Map<String, Object> map) {
+        if (map == null) return null;
+        // Deserialize result item
+        Object resultObj = map.get("result");
+        ItemStack result;
+        if (resultObj instanceof Map<?, ?> resultMap) {
+            result = ItemStack.deserialize(toStringKeyMap(resultMap));
+        } else {
+            return null;
+        }
+        int maxUses = map.containsKey("maxUses") ? ((Number) map.get("maxUses")).intValue() : 1;
+        boolean experienceReward = map.containsKey("experienceReward") ? Boolean.TRUE.equals(map.get("experienceReward")) : true;
+        int villagerExperience = map.containsKey("villagerExperience") ? ((Number) map.get("villagerExperience")).intValue() : 0;
+        float priceMultiplier = map.containsKey("priceMultiplier") ? ((Number) map.get("priceMultiplier")).floatValue() : 0.0f;
+        int demand = map.containsKey("demand") ? ((Number) map.get("demand")).intValue() : 0;
+        int specialPrice = map.containsKey("specialPrice") ? ((Number) map.get("specialPrice")).intValue() : 0;
+        int uses = map.containsKey("uses") ? ((Number) map.get("uses")).intValue() : 0;
+
+        org.bukkit.inventory.MerchantRecipe recipe = new org.bukkit.inventory.MerchantRecipe(
+            result, uses, maxUses, experienceReward, villagerExperience, priceMultiplier, demand, specialPrice
+        );
+
+        // Deserialize ingredients
+        Object ingredientsObj = map.get("ingredients");
+        if (ingredientsObj instanceof List<?> ingredientsList) {
+            List<ItemStack> ingredients = new ArrayList<>();
+            for (Object ingObj : ingredientsList) {
+                if (ingObj instanceof Map<?, ?> ingMap) {
+                    ItemStack ing = ItemStack.deserialize(toStringKeyMap(ingMap));
+                    ingredients.add(ing);
+                }
+            }
+            recipe.setIngredients(ingredients);
+        }
+
+        return recipe;
+    }
+
+    private Map<String, Object> toStringKeyMap(Map<?, ?> map) {
+        Map<String, Object> result = new java.util.LinkedHashMap<>();
+        for (Map.Entry<?, ?> entry : map.entrySet()) {
+            result.put(String.valueOf(entry.getKey()), entry.getValue());
+        }
+        return result;
+    }
+
     private Location toLocation(Object arg, Entity context) {
         if (arg instanceof Location loc) return loc;
         if (arg instanceof List<?> list && list.size() >= 3) {
@@ -1885,6 +1950,51 @@ private Object invokeMobMethod(Entity entity, String method, List<Object> args)
                 goals.removeAllGoals(mob);
                 return null;
             }
+            // ── Villager trades ──────────────────────────────────────
+            case "getRecipes" -> {
+                if (!(mob instanceof org.bukkit.entity.AbstractVillager villager)) return UNHANDLED;
+                List<org.bukkit.inventory.MerchantRecipe> recipes = villager.getRecipes();
+                List<Map<String, Object>> result = new ArrayList<>();
+                for (org.bukkit.inventory.MerchantRecipe recipe : recipes) {
+                    result.add(serializeMerchantRecipe(recipe));
+                }
+                return result;
+            }
+            case "getRecipeCount" -> {
+                if (!(mob instanceof org.bukkit.entity.AbstractVillager villager)) return UNHANDLED;
+                return villager.getRecipeCount();
+            }
+            case "setRecipes" -> {
+                if (!(mob instanceof org.bukkit.entity.AbstractVillager villager)) return UNHANDLED;
+                if (args.isEmpty()) return null;
+                @SuppressWarnings("unchecked")
+                List<Map<String, Object>> recipeMaps = (List<Map<String, Object>>) args.get(0);
+                List<org.bukkit.inventory.MerchantRecipe> recipes = new ArrayList<>();
+                for (Map<String, Object> map : recipeMaps) {
+                    org.bukkit.inventory.MerchantRecipe recipe = deserializeMerchantRecipe(map);
+                    if (recipe != null) recipes.add(recipe);
+                }
+                villager.setRecipes(recipes);
+                return null;
+            }
+            case "addRecipe" -> {
+                if (!(mob instanceof org.bukkit.entity.AbstractVillager villager)) return UNHANDLED;
+                if (args.isEmpty()) return null;
+                @SuppressWarnings("unchecked")
+                Map<String, Object> recipeMap = (Map<String, Object>) args.get(0);
+                org.bukkit.inventory.MerchantRecipe recipe = deserializeMerchantRecipe(recipeMap);
+                if (recipe != null) {
+                    List<org.bukkit.inventory.MerchantRecipe> recipes = new ArrayList<>(villager.getRecipes());
+                    recipes.add(recipe);
+                    villager.setRecipes(recipes);
+                }
+                return null;
+            }
+            case "clearRecipes" -> {
+                if (!(mob instanceof org.bukkit.entity.AbstractVillager villager)) return UNHANDLED;
+                villager.setRecipes(new ArrayList<>());
+                return null;
+            }
         }
         return UNHANDLED;
     }

src/main/java/com/pyjavabridge/BridgeInstance.java

@@ -366,6 +366,16 @@ class Villager(Entity):
     def villager_experience(self) -> int: ...
     @villager_experience.setter
     def villager_experience(self, value: int) -> None: ...
+    @property
+    def recipes(self) -> list[dict]: ...
+    @recipes.setter
+    def recipes(self, value: list[dict]) -> None: ...
+    @property
+    def recipe_count(self) -> int: ...
+    def add_recipe(self, result: dict, ingredients: list[dict], max_uses: int = 1,
+                   experience_reward: bool = True, villager_experience: int = 0,
+                   price_multiplier: float = 0.0, demand: int = 0, special_price: int = 0) -> None: ...
+    def clear_recipes(self) -> None: ...
 
 class ItemFrame(Entity):
     @property

src/main/resources/python/bridge/__init__.pyi

@@ -134,7 +134,7 @@ def broadcast(self, message: str):
         """Send a message to all online guild members."""
         async def _send():
             from bridge import server
-            online = await server.players
+            online = server.players
             for p in online:
                 if str(p.uuid) in self._members:
                     await p.send_message(f"§6[Guild] §f{message}")

src/main/resources/python/bridge/extensions/guild.py

@@ -60,7 +60,7 @@ async def _refresh(self):
         from bridge import server
         if self._hologram is None or self._get_metric is None:
             return
-        online = await server.players
+        online = server.players
         scores: List[tuple[str, float]] = []
         for p in online:
             try:

src/main/resources/python/bridge/extensions/leaderboard.py

@@ -154,7 +154,7 @@ async def _range_check_loop(self):
                 if npc_loc is None:
                     await server.after(20)
                     continue
-                online = await server.players
+                online = server.players
                 for p in online:
                     puuid = str(p.uuid)
                     try:

src/main/resources/python/bridge/extensions/npc.py

@@ -79,7 +79,7 @@ async def _track_loop(cls):
         from bridge import server
         while True:
             try:
-                online = await server.players
+                online = server.players
                 for region in list(cls._all_regions):
                     for p in online:
                         puuid = str(p.uuid)

src/main/resources/python/bridge/extensions/region.py

@@ -874,6 +874,51 @@ def villager_experience(self) -> int:
     def villager_experience(self, value: int):
         self._call("setVillagerExperience", int(value))
 
+    @property
+    def recipes(self) -> list[dict]:
+        """Get the villager's trade recipes."""
+        return self._call_sync("getRecipes")
+
+    @recipes.setter
+    def recipes(self, value: list[dict]):
+        """Set the villager's trade recipes."""
+        self._call("setRecipes", value)
+
+    @property
+    def recipe_count(self) -> int:
+        """Get the number of trade recipes."""
+        return self._call_sync("getRecipeCount")
+
+    def add_recipe(self, result: dict, ingredients: list[dict], max_uses: int = 1,
+                   experience_reward: bool = True, villager_experience: int = 0,
+                   price_multiplier: float = 0.0, demand: int = 0, special_price: int = 0):
+        """Add a trade recipe to this villager.
+
+        Args:
+            result: Serialized ItemStack dict for the result item.
+            ingredients: List of serialized ItemStack dicts (1-2 items).
+            max_uses: Maximum number of uses before the trade locks.
+            experience_reward: Whether the trade rewards experience.
+            villager_experience: Experience given to the villager.
+            price_multiplier: Price multiplier based on demand.
+            demand: Current demand for this trade.
+            special_price: Special price adjustment.
+        """
+        self._call("addRecipe", {
+            "result": result,
+            "ingredients": ingredients,
+            "maxUses": max_uses,
+            "experienceReward": experience_reward,
+            "villagerExperience": villager_experience,
+            "priceMultiplier": price_multiplier,
+            "demand": demand,
+            "specialPrice": special_price,
+        })
+
+    def clear_recipes(self):
+        """Remove all trade recipes from this villager."""
+        self._call("clearRecipes")
+
 
 class ItemFrame(Entity):
     """ItemFrame entity."""