maybe implement datapack features? havent tested someone please do.

Author: Omena0

docs/src/datapack_runtime.md

@@ -0,0 +1,69 @@
+---
+title: Datapack (runtime)
+subtitle: Register datapack-like definitions at runtime from Python
+---
+
+# Datapack (runtime)
+
+The `Datapack` runtime proxy lets Python code register the same kinds of JSON definitions datapacks provide (models, advancements, predicates, worldgen, tags, registries, damage/chat types) without writing datapack files. Instead these definitions are sent to the Java side where they are collected and may be applied to the running server.
+
+> NOTE: The current implementation collects and stores registered definitions in Java (`DatapackFacade`) and exposes an `apply_all()` request. Actual application to all Minecraft registries is best-effort and currently a TODO on the Java side; see "Limitations" below.
+
+## Usage
+
+```python
+from bridge import Datapack
+
+# create a runtime proxy (no files created)
+dp = Datapack()
+
+# register a model (namespace, path, model-json)
+dp.register_model("myns", "item/custom_sword", {
+    "parent": "item/generated",
+    "textures": {"layer0": "myns:item/custom_sword"}
+})
+
+# register an advancement
+adv = {
+    "display": {"title": "First Step", "description": "Do a thing", "icon": {"item": "minecraft:stone"}},
+    "criteria": {"do_thing": {"trigger": "minecraft:impossible"}}
+}
+dp.register_advancement("myns", "root/first", adv)
+
+# register a predicate
+pred = {"condition": "minecraft:entity_properties", "entity": {"type": "minecraft:player"}}
+dp.register_predicate("myns", "preds/is_player", pred)
+
+# when ready, ask Java to attempt to apply all registered entries
+dp.apply_all()
+```
+
+## API reference
+
+- `Datapack().register_model(namespace, path, model_json)` — Register an item/block model JSON.
+- `Datapack().register_advancement(namespace, path, advancement_json)` — Register an advancement definition.
+- `Datapack().register_predicate(namespace, path, predicate_json)` — Register a predicate definition.
+- `Datapack().register_worldgen(namespace, category, path, json_obj)` — Register worldgen entries (dimensions, noise, carvers, structures).
+- `Datapack().register_tag(namespace, tag_type, tag_id, values, replace=False)` — Register a datapack tag.
+- `Datapack().register_registry_entry(namespace, registry, path, entry_json)` — Register an entry for a datapack registry.
+- `Datapack().register_damage_type(namespace, id, json_obj)` — Register a damage type (vends to registry API).
+- `Datapack().register_chat_type(namespace, id, json_obj)` — Register a chat type.
+- `Datapack().apply_all()` — Ask Java to apply the collected entries to the running server.
+
+## Limitations (current implementation)
+
+- The Python API and Java `DatapackFacade` collect and store JSON for all the above features, but the Java side currently logs and holds the data; the actual logic to inject those JSON definitions directly into Paper/Minecraft registries (models, registry entries, worldgen registries) is not yet implemented — `DatapackFacade.applyAll()` currently schedules a task and logs counts.
+
+- Some datapack features (advancements, predicates) are more straightforward to register at runtime via the Bukkit/Paper APIs and can be implemented more quickly. Others (custom registry entries, worldgen/noise/carvers, model asset wiring) require careful use of Paper's registry access API and may be version-specific.
+
+- Model textures/assets: "applying" a model normally requires resource-pack assets (textures, model files) to be available to clients. Registering model JSON server-side without providing the actual asset files on clients will not display custom textures unless a matching resource pack is present. `item_model` in `ItemBuilder` can point to a model; you still need client-side assets for visuals.
+
+## Recommended next steps to fully replace datapacks at runtime
+
+- Implement runtime application in `DatapackFacade.applyAll()` to map stored JSON into server registries using Paper's `RegistryAccess`/`RegistryKey` APIs and server internals.
+- For model assets: provide either a resource-pack delivery mechanism or fall back to only registering behaviors that don't rely on client assets.
+- Implement safe rollback / validation and ensure operations run on the main server thread.
+
+## Summary
+
+The new `Datapack` wrapper allows Python code to express everything datapacks can describe and sends that data to Java at runtime. Right now it collects and forwards definitions; to fully match datapacks you need the Java-side application logic (server registry injection and asset delivery) implemented as described above.

docs/src/items/itembuilder.md

@@ -163,6 +163,17 @@ Set custom model data for resource packs.
 - **Parameters:**
   - `value` (`int`) — Model data value.
 
+### model
+
+```python
+builder.model("myns:item/custom_sword")
+```
+
+Set the 1.21.11 `item_model` property which points to a model definition resource.
+
+- **Parameters:**
+  - `model` (`str`) — Resource location string (e.g. `"myns:item/custom_sword"`).
+
 ### attributes
 
 ```python

releases/pyjavabridge-dev.jar

@@ -128,6 +128,7 @@ public class BridgeInstance {
     private final MetricsFacade metricsFacade;
     private final RefFacade refFacade;
     private final CommandsFacade commandsFacade;
+    private final DatapackFacade datapackFacade;
 
     private DataInputStream reader;
     private DataOutputStream writer;
@@ -149,6 +150,7 @@ public class BridgeInstance {
         this.metricsFacade = new MetricsFacade(plugin);
         this.refFacade = new RefFacade(this);
         this.commandsFacade = new CommandsFacade(plugin, this);
+        this.datapackFacade = new DatapackFacade(plugin);
 
         Bukkit.getPluginManager().registerEvents(new Listener() {
             @EventHandler
@@ -2628,6 +2630,7 @@ private Object resolveTarget(String targetName, JsonObject argsObj) throws Excep
             case "ref" -> refFacade;
             case "reflect" -> reflectFacade;
             case "commands" -> commandsFacade;
+            case "datapack" -> datapackFacade;
             case "region" -> regionFacade;
             case "particle" -> particleFacade;
             default -> throw new IllegalArgumentException("Unknown target: " + targetName);

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

@@ -0,0 +1,255 @@
+package com.pyjavabridge.facade;
+
+import com.pyjavabridge.PyJavaBridgePlugin;
+import com.google.gson.JsonObject;
+import org.bukkit.Bukkit;
+
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.Map;
+
+public class DatapackFacade {
+    private final PyJavaBridgePlugin plugin;
+    private final Map<String, JsonObject> models = new ConcurrentHashMap<>();
+    private final Map<String, JsonObject> advancements = new ConcurrentHashMap<>();
+    private final Map<String, JsonObject> predicates = new ConcurrentHashMap<>();
+    private final Map<String, JsonObject> registries = new ConcurrentHashMap<>();
+
+    public DatapackFacade(PyJavaBridgePlugin plugin) {
+        this.plugin = plugin;
+    }
+
+    public void registerModel(String namespace, String path, JsonObject json) {
+        String key = namespace + ":" + path;
+        models.put(key, json);
+        plugin.getLogger().info("Registered model: " + key);
+    }
+
+    public void registerAdvancement(String namespace, String path, JsonObject json) {
+        String key = namespace + ":" + path;
+        advancements.put(key, json);
+        plugin.getLogger().info("Registered advancement: " + key);
+    }
+
+    public void registerPredicate(String namespace, String path, JsonObject json) {
+        String key = namespace + ":" + path;
+        predicates.put(key, json);
+        plugin.getLogger().info("Registered predicate: " + key);
+    }
+
+    public void registerRegistryEntry(String namespace, String registry, String path, JsonObject json) {
+        String key = namespace + ":" + registry + ":" + path;
+        registries.put(key, json);
+        plugin.getLogger().info("Registered registry entry: " + key);
+    }
+
+    public void registerDamageType(String namespace, String id, JsonObject json) {
+        registerRegistryEntry(namespace, "damage_types", id, json);
+    }
+
+    public void registerChatType(String namespace, String id, JsonObject json) {
+        registerRegistryEntry(namespace, "chat_types", id, json);
+    }
+
+    public void applyAll() {
+        Bukkit.getScheduler().runTask(plugin, () -> {
+            plugin.getLogger().info("Applying datapack entries in-memory: models=" + models.size()
+                    + " advancements=" + advancements.size()
+                    + " predicates=" + predicates.size()
+                    + " registries=" + registries.size());
+
+            // Best-effort in-memory injection using reflection into server internals.
+            // This attempts to find the server's advancement manager and load
+            // the JsonObjects directly without writing datapack files.
+            try {
+                Object craftServer = Bukkit.getServer();
+                Class<?> craftServerClass = craftServer.getClass();
+
+                // Obtain NMS server (CraftServer#getServer)
+                Object nmsServer = null;
+                try {
+                    java.lang.reflect.Method getServer = craftServerClass.getMethod("getServer");
+                    nmsServer = getServer.invoke(craftServer);
+                } catch (NoSuchMethodException ignored) {
+                    // older/newer mappings: try field access
+                    try {
+                        java.lang.reflect.Field f = craftServerClass.getDeclaredField("server");
+                        f.setAccessible(true);
+                        nmsServer = f.get(craftServer);
+                    } catch (Exception ex) {
+                        plugin.getLogger().warning("Could not obtain NMS server handle: " + ex.getMessage());
+                    }
+                }
+
+                if (nmsServer == null) {
+                    plugin.getLogger().severe("In-memory apply failed: NMS server handle unavailable");
+                    return;
+                }
+
+                Class<?> nmsServerClass = nmsServer.getClass();
+
+                // Try to find an advancement manager field or method on the server
+                Object advancementManager = null;
+                for (java.lang.reflect.Field f : nmsServerClass.getDeclaredFields()) {
+                    if (f.getType().getSimpleName().toLowerCase().contains("advancement")) {
+                        f.setAccessible(true);
+                        try { advancementManager = f.get(nmsServer); } catch (Exception ignored) {}
+                        if (advancementManager != null) break;
+                    }
+                }
+                if (advancementManager == null) {
+                    for (java.lang.reflect.Method m : nmsServerClass.getDeclaredMethods()) {
+                        if (m.getReturnType().getSimpleName().toLowerCase().contains("advancement") && m.getParameterCount() == 0) {
+                            m.setAccessible(true);
+                            try { advancementManager = m.invoke(nmsServer); } catch (Exception ignored) {}
+                            if (advancementManager != null) break;
+                        }
+                    }
+                }
+
+                if (advancementManager != null) {
+                    Class<?> advClass = advancementManager.getClass();
+
+                    // Find a method that accepts a resource key and a JsonObject / JsonElement
+                    java.lang.reflect.Method loaderMethod = null;
+                    for (java.lang.reflect.Method m : advClass.getDeclaredMethods()) {
+                        String name = m.getName().toLowerCase();
+                        if ((name.contains("load") || name.contains("add") || name.contains("register") || name.contains("parse"))
+                                && m.getParameterCount() >= 2) {
+                            Class<?>[] params = m.getParameterTypes();
+                            // look for (ResourceLocation/ResourceKey/Identifier, JsonObject/json)
+                            if (params.length >= 2 && params[1].getName().contains("Json")) {
+                                loaderMethod = m;
+                                break;
+                            }
+                        }
+                    }
+
+                    // Prepare ResourceLocation class if present
+                    Class<?> resourceLocationClass = null;
+                    try {
+                        resourceLocationClass = Class.forName("net.minecraft.resources.ResourceLocation");
+                    } catch (ClassNotFoundException ignored) {}
+
+                    for (Map.Entry<String, JsonObject> e : advancements.entrySet()) {
+                        try {
+                            String[] parts = e.getKey().split(":", 2);
+                            if (parts.length != 2) continue;
+                            String ns = parts[0];
+                            String path = parts[1];
+
+                            Object keyObj = null;
+                            if (resourceLocationClass != null) {
+                                try {
+                                    java.lang.reflect.Constructor<?> rc = resourceLocationClass.getConstructor(String.class, String.class);
+                                    keyObj = rc.newInstance(ns, path);
+                                } catch (NoSuchMethodException ex) {
+                                    // try single-string constructor
+                                    try {
+                                        java.lang.reflect.Constructor<?> rc2 = resourceLocationClass.getConstructor(String.class);
+                                        keyObj = rc2.newInstance((Object)(ns + ":" + path));
+                                    } catch (Exception ex2) { keyObj = null; }
+                                }
+                            }
+
+                            if (loaderMethod != null) {
+                                // Attempt to call loaderMethod(keyObj, json)
+                                loaderMethod.setAccessible(true);
+                                if (keyObj != null) {
+                                    try {
+                                        loaderMethod.invoke(advancementManager, keyObj, e.getValue());
+                                        plugin.getLogger().info("Injected advancement in-memory: " + e.getKey());
+                                        continue;
+                                    } catch (Exception ex) {
+                                        // fall through to other attempts
+                                    }
+                                }
+                            }
+
+                            // As a fallback, try calling a method that accepts (String, JsonObject)
+                            java.lang.reflect.Method stringLoader = null;
+                            for (java.lang.reflect.Method m : advClass.getDeclaredMethods()) {
+                                if (m.getParameterCount() >= 2 && m.getParameterTypes()[0] == String.class && m.getParameterTypes()[1].getName().contains("Json")) {
+                                    stringLoader = m;
+                                    break;
+                                }
+                            }
+                            if (stringLoader != null) {
+                                stringLoader.setAccessible(true);
+                                stringLoader.invoke(advancementManager, ns + ":" + path, e.getValue());
+                                plugin.getLogger().info("Injected advancement (string fallback): " + e.getKey());
+                                continue;
+                            }
+
+                            plugin.getLogger().warning("Could not inject advancement in-memory, no compatible loader found for: " + e.getKey());
+                        } catch (Exception ex) {
+                            plugin.getLogger().warning("Failed to inject advancement " + e.getKey() + ": " + ex.getMessage());
+                        }
+                    }
+                } else {
+                    plugin.getLogger().warning("Advancement manager not found on server; in-memory injection skipped.");
+                }
+
+                // Predicates: try similar approach for predicate/loot manager
+                Object predicateManager = null;
+                for (java.lang.reflect.Field f : nmsServerClass.getDeclaredFields()) {
+                    if (f.getType().getSimpleName().toLowerCase().contains("predicate") || f.getName().toLowerCase().contains("loot") || f.getName().toLowerCase().contains("predicate")) {
+                        f.setAccessible(true);
+                        try { predicateManager = f.get(nmsServer); } catch (Exception ignored) {}
+                        if (predicateManager != null) break;
+                    }
+                }
+                if (predicateManager == null) {
+                    for (java.lang.reflect.Method m : nmsServerClass.getDeclaredMethods()) {
+                        if (m.getReturnType().getSimpleName().toLowerCase().contains("predicate") && m.getParameterCount() == 0) {
+                            m.setAccessible(true);
+                            try { predicateManager = m.invoke(nmsServer); } catch (Exception ignored) {}
+                            if (predicateManager != null) break;
+                        }
+                    }
+                }
+
+                if (predicateManager != null) {
+                    Class<?> pmClass = predicateManager.getClass();
+                    java.lang.reflect.Method loader = null;
+                    for (java.lang.reflect.Method m : pmClass.getDeclaredMethods()) {
+                        String name = m.getName().toLowerCase();
+                        if ((name.contains("load") || name.contains("parse") || name.contains("register")) && m.getParameterCount() >= 2 && m.getParameterTypes()[1].getName().contains("Json")) {
+                            loader = m;
+                            break;
+                        }
+                    }
+
+                    for (Map.Entry<String, JsonObject> e : predicates.entrySet()) {
+                        try {
+                            String[] parts = e.getKey().split(":", 2);
+                            if (parts.length != 2) continue;
+                            String ns = parts[0];
+                            String path = parts[1];
+
+                            if (loader != null) {
+                                loader.setAccessible(true);
+                                // attempt loader with (ResourceLocation/String, JsonObject)
+                                try {
+                                    loader.invoke(predicateManager, ns + ":" + path, e.getValue());
+                                    plugin.getLogger().info("Injected predicate in-memory: " + e.getKey());
+                                    continue;
+                                } catch (Exception ex) {
+                                    // ignore and try other options
+                                }
+                            }
+
+                            plugin.getLogger().warning("Could not inject predicate in-memory, no compatible loader found for: " + e.getKey());
+                        } catch (Exception ex) {
+                            plugin.getLogger().warning("Failed to inject predicate " + e.getKey() + ": " + ex.getMessage());
+                        }
+                    }
+                } else {
+                    plugin.getLogger().warning("Predicate/loot manager not found on server; in-memory injection skipped.");
+                }
+
+            } catch (Throwable ex) {
+                plugin.getLogger().severe("In-memory apply failed: " + ex.getMessage());
+            }
+        });
+    }
+}