f

engine/src/main/java/com/volmit/iris/engine/Engine.java

@@ -33,7 +33,7 @@ public class Engine implements Closeable {
     private final EngineSeedManager seedManager;
     private final EngineData data;
 
-    public Engine(IrisPlatform platform, PlatformWorld world, EngineConfiguration configuration) {
+    public Engine(IrisPlatform platform, PlatformWorld world, EngineConfiguration configuration) throws IOException {
         PrecisionStopwatch p = PrecisionStopwatch.start();
         this.configuration = configuration;
         this.platform = platform;
@@ -56,6 +56,9 @@ public class Engine implements Closeable {
                     .build())
                 .build())
             .build();
+        data.loadData(getConfiguration().isMutable()
+                ? getPlatform().getStudioFolder(getConfiguration().getDimension())
+                : getWorld().getIrisDataFolder());
     }
 
     public PlatformBlock block(String block)

engine/src/main/java/com/volmit/iris/engine/EngineConfiguration.java

@@ -22,4 +22,7 @@ public class EngineConfiguration {
 
     @Builder.Default
     private int threadPriority = 3;
+
+    @Builder.Default
+    private String dimension = "overworld";
 }

engine/src/main/java/com/volmit/iris/engine/EngineData.java

@@ -1,7 +1,11 @@
 package com.volmit.iris.engine;
 
 import art.arcane.amulet.concurrent.J;
+import art.arcane.amulet.io.IO;
 import art.arcane.amulet.io.JarLoader;
+import art.arcane.cram.PakFile;
+import art.arcane.cram.PakKey;
+import art.arcane.cram.PakResource;
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
 import com.google.gson.TypeAdapterFactory;
@@ -9,6 +13,7 @@ import com.volmit.iris.engine.resolver.*;
 import lombok.Data;
 
 import java.io.File;
+import java.io.IOException;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -19,10 +24,9 @@ public class EngineData {
     private final Engine engine;
     private final Gson gson;
     private List<Resolvable> resolvableTypes;
-    private final Map<Class<? extends Resolvable>, Resolver<? extends Resolvable>> resolvers;
+    private final Map<Class<?>, Resolver<?>> resolvers;
 
-    public EngineData(Engine engine)
-    {
+    public EngineData(Engine engine) throws IOException {
         this.engine = engine;
         this.resolvers = new HashMap<>();
         this.resolvableTypes =  J.attempt(() -> new JarLoader(getClass()).all().parallel()
@@ -37,44 +41,77 @@ public class EngineData {
         i("Registered " + resolvableTypes.size() + " Mutators with " + resolvableTypes.stream().filter(i -> i instanceof TypeAdapterFactory).count() + " Type Adapter Factories");
     }
 
-    public <T extends Resolvable> void registerResolver(Class<T> type, Resolver<T> resolver, String... namespaces)
+    public void registerResolver(Class<?> type, Resolver<?> resolver, String namespace)
     {
         if(resolvers.containsKey(type)) {
-            Resolver<T> existing = (Resolver<T>) resolvers.get(type);
-
-            if(existing instanceof CompositeResolver<T> c) {
-                Map<String, Resolver<T>> oresolvers = c.getResolvers();
-
-                if(namespaces.length > 1) {
-                    CompositeResolver<T> n = (CompositeResolver<T>) resolver;
-
-                    for(String i : n.getResolvers().keySet()) {
-                        if(oresolvers.containsKey(i)) {
-                            oresolvers.put(i, new MergedResolver<>(oresolvers.get(i), n.getResolvers().get(i)));
-                        }
-
-                        else
-                        {
-                            oresolvers.put(i, n.getResolvers().get(i));
-                        }
-                    }
-                }
-
-                else
-                {
-
-                }
-            }
+            Resolver r = resolvers.get(type);
+            resolvers.put(type, r.and(namespace, r));
         }
 
-        else
-        {
+        else {
             resolvers.put(type, resolver);
         }
     }
 
-    public void loadData(File folder)
-    {
+    public void loadData(File folder) throws IOException {
+        i("Loading Data in " + folder.getPath());
+        for(File i : folder.listFiles()) {
+            if(i.isDirectory()) {
+                loadDataNamespaced(i, i.getName());
+            }
+        }
+    }
 
+    public void loadDataNamespaced(File folder, String namespace) throws IOException {
+        i("Loading Namespace " + namespace + " in " + folder.getPath());
+        for(Resolvable i : resolvableTypes)
+        {
+            new File(folder, i.entity().getId()).mkdirs();
+            IO.writeAll(
+                    new File(new File(folder, i.entity().getId()), "example.json"), gson.toJson(i));
+        }
+
+        for(File i : folder.listFiles())
+        {
+            if(i.isDirectory()) {
+                loadDataFolder(i, namespace);
+            }
+
+            else if(i.getName().endsWith(".dat")) {
+                loadPakFile(folder, i.getName().split("\\Q.\\E")[0]);
+            }
+        }
+    }
+
+    public void loadDataFolder(File folder, String namespace) {
+        for(Resolvable i : resolvableTypes)
+        {
+            if(!folder.getName().equals(i.entity().getId())) {
+                continue;
+            }
+
+            registerResolver(i.getClass(), Resolver.hotDirectoryJson(namespace, i.getClass(), folder, gson), namespace);
+        }
+    }
+
+    public void loadPakFile(File folder, String name) throws IOException {
+        PakFile pakFile = new PakFile(folder, name);
+        Map<PakKey, PakResource> resources = pakFile.getAllResources();
+
+        for(Resolvable i : resolvableTypes)
+        {
+            Class<? extends Resolvable> resolvableClass = i.getClass();
+            CompositeResolver<?> composite = Resolver.frozen(resources, (p) -> p.getClass().equals(resolvableClass));
+
+            for(String j : composite.getResolvers().keySet())
+            {
+                Resolver<? extends Resolvable> resolver = composite.getResolvers().get(i);
+                this.registerResolver(i.getClass(), resolver, j);
+            }
+        }
+    }
+
+    public void printResolvers() {
+        resolvers.forEach((k, i) -> i.print(k.simpleName(), this));
     }
 }

engine/src/main/java/com/volmit/iris/engine/resolver/CompositeResolver.java

@@ -1,8 +1,10 @@
 package com.volmit.iris.engine.resolver;
 
+import art.arcane.amulet.format.Form;
 import com.volmit.iris.platform.PlatformNamespaceKey;
 import lombok.Data;
 
+import java.util.Arrays;
 import java.util.Map;
 
 @Data
@@ -36,4 +38,28 @@ public class CompositeResolver<T extends Resolvable> implements Resolver<T> {
 
         return null;
     }
+
+    @Override
+    public Resolver<T> and(String namespace, Resolver<T> resolver) {
+        Map<String, Resolver<T>> resolvers = this.resolvers.copy();
+
+        if(hasNamespace(namespace)) {
+            resolvers.put(namespace, resolvers.get(namespace).and(namespace, resolver));
+        }
+
+        else {
+            resolvers.put(namespace, resolver);
+        }
+
+        return new CompositeResolver<>(resolvers);
+    }
+
+    @Override
+    public void print(String type, Object printer, int indent) {
+        printer.i(Form.repeat(" ", indent) + "Composite[" + Arrays.toString(getNamespaces()) + "] " + type);
+
+        for(Resolver<T> i : getResolvers().values()) {
+            i.print(type, printer, indent + 2);
+        }
+    }
 }

engine/src/main/java/com/volmit/iris/engine/resolver/FrozenResolver.java

@@ -1,5 +1,6 @@
 package com.volmit.iris.engine.resolver;
 
+import art.arcane.amulet.format.Form;
 import com.volmit.iris.platform.PlatformNamespaceKey;
 import lombok.Data;
 
@@ -30,4 +31,18 @@ public class FrozenResolver<T extends Resolvable> implements Resolver<T> {
     public T resolve(String key) {
         return registry.get(key);
     }
+
+    @Override
+    public void print(String type, Object printer, int indent) {
+        printer.i(Form.repeat(" ", indent) + "Frozen[" + namespace + "] " + type);
+    }
+
+    @Override
+    public Resolver<T> and(String namespace, Resolver<T> resolver) {
+        if(!namespace.equals(getNamespace())) {
+            return new CompositeResolver<>(Map.of(namespace, resolver, getNamespace(), this));
+        }
+
+        return new MergedNamespaceResolver<>(namespace, this, resolver);
+    }
 }

engine/src/main/java/com/volmit/iris/engine/resolver/HotResolver.java

@@ -1,5 +1,6 @@
 package com.volmit.iris.engine.resolver;
 
+import art.arcane.amulet.format.Form;
 import com.github.benmanes.caffeine.cache.CacheLoader;
 import com.github.benmanes.caffeine.cache.Caffeine;
 import com.github.benmanes.caffeine.cache.LoadingCache;
@@ -55,4 +56,18 @@ public class HotResolver<T extends Resolvable> implements Resolver<T>, CacheLoad
     public @Nullable T load(String key) {
         return loader.apply(key);
     }
+
+    @Override
+    public Resolver<T> and(String namespace, Resolver<T> resolver) {
+        if(!namespace.equals(getNamespace())) {
+            return new CompositeResolver<>(Map.of(namespace, resolver, getNamespace(), this));
+        }
+
+        return new MergedNamespaceResolver<>(namespace, this, resolver);
+    }
+
+    @Override
+    public void print(String type, Object printer, int indent) {
+        printer.i(Form.repeat(" ", indent) + "Hot[" + namespace + "] " + type);
+    }
 }

engine/src/main/java/com/volmit/iris/engine/resolver/MergedNamespaceResolver.java

@@ -0,0 +1,80 @@
+package com.volmit.iris.engine.resolver;
+
+import art.arcane.amulet.format.Form;
+import com.volmit.iris.platform.PlatformNamespaceKey;
+import lombok.Data;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+
+@Data
+public class MergedNamespaceResolver<T extends Resolvable> implements Resolver<T> {
+    private final String namespace;
+    private final List<Resolver<T>> resolvers;
+
+    public MergedNamespaceResolver(String namespace, Resolver<T>... resolvers)
+    {
+        this(namespace, Arrays.stream(resolvers).toList());
+    }
+
+    public MergedNamespaceResolver(String namespace, List<Resolver<T>> resolvers)
+    {
+        this.namespace = namespace;
+        this.resolvers = resolvers;
+    }
+
+    @Override
+    public boolean hasNamespace(String namespace) {
+        return this.namespace.equals(namespace);
+    }
+
+    @Override
+    public T resolve(PlatformNamespaceKey key) {
+        for(Resolver<T> i : resolvers) {
+            T t = i.resolve(key);
+
+            if(t != null)
+            {
+                return t;
+            }
+        }
+
+        return null;
+    }
+
+    @Override
+    public T resolve(String key) {
+        for(Resolver<T> i : resolvers) {
+            T t = i.resolve(key);
+
+            if(t != null)
+            {
+                return t;
+            }
+        }
+
+        return null;
+    }
+
+    @Override
+    public void print(String type, Object printer, int indent) {
+        printer.i(Form.repeat(" ", indent) + "Merged[" + namespace + "] " + type);
+
+        for(Resolver<T> i : getResolvers()) {
+            i.print(type, printer, indent + 2);
+        }
+    }
+
+    @Override
+    public Resolver<T> and(String namespace, Resolver<T> resolver) {
+        if(namespace.equals(getNamespace()))
+        {
+            List<Resolver<T>> r = resolvers.copy();
+            r.add(resolver);
+            return new MergedNamespaceResolver<>(namespace, r);
+        }
+
+        return new CompositeResolver<>(Map.of(getNamespace(), this, namespace, resolver));
+    }
+}

engine/src/main/java/com/volmit/iris/engine/resolver/MergedResolver.java

@@ -1,60 +0,0 @@
-package com.volmit.iris.engine.resolver;
-
-import com.volmit.iris.platform.PlatformNamespaceKey;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-
-public class MergedResolver<T extends Resolvable> implements Resolver<T> {
-    private final List<Resolver<T>> resolvers;
-
-    public MergedResolver(Resolver<T>... resolvers)
-    {
-        this(Arrays.stream(resolvers).toList());
-    }
-
-    public MergedResolver(List<Resolver<T>> resolvers)
-    {
-        this.resolvers = resolvers;
-    }
-
-    @Override
-    public boolean hasNamespace(String namespace) {
-        for(Resolver<T> i : resolvers) {
-            if(i.hasNamespace(namespace)) {
-                return true;
-            }
-        }
-
-        return false;
-    }
-
-    @Override
-    public T resolve(PlatformNamespaceKey key) {
-        for(Resolver<T> i : resolvers) {
-            T t = i.resolve(key);
-
-            if(t != null)
-            {
-                return t;
-            }
-        }
-
-        return null;
-    }
-
-    @Override
-    public T resolve(String key) {
-        for(Resolver<T> i : resolvers) {
-            T t = i.resolve(key);
-
-            if(t != null)
-            {
-                return t;
-            }
-        }
-
-        return null;
-    }
-}

engine/src/main/java/com/volmit/iris/engine/resolver/Resolvable.java

@@ -24,6 +24,10 @@ public interface Resolvable extends PlatformNamespaced, PlatformNamespacedMutabl
         }
     }
 
+    default Entity.ResolverEntityData entity() {
+        return new Entity.ResolverEntityData(getClass().getDeclaredAnnotation(Resolvable.Entity.class));
+    }
+
     default <T> void writeSafeJson(TypeAdapter<T> delegate, JsonWriter out, T value) {
         try {
             delegate.write(out, value);

engine/src/main/java/com/volmit/iris/engine/resolver/Resolver.java

@@ -17,7 +17,7 @@ import java.util.function.Predicate;
 
 public interface Resolver<T extends Resolvable> {
     @SuppressWarnings("unchecked")
-    static <F extends Resolvable> Resolver<F> frozen(Map<PakKey, PakResource> resources, Predicate<PakResource> isTypePredicate) {
+    static <F extends Resolvable> CompositeResolver<F> frozen(Map<PakKey, PakResource> resources, Predicate<PakResource> isTypePredicate) {
         Map<String, Map<String, F>> resolvables = new HashMap<>();
         Map<String, Resolver<F>> resolvers = new HashMap<>();
 
@@ -85,7 +85,12 @@ public interface Resolver<T extends Resolvable> {
         return hasNamespace(key.getNamespace()) && resolve(key) != null;
     }
 
-    default Resolver<T> addResolver(Resolver<T> resolver, String namespace) {
-        return new MergedResolver<>(resolver, this);
+    Resolver<T> and(String namespace, Resolver<T> resolver);
+
+    default void print(String type, Object printer)
+    {
+        print(type, printer, 0);
     }
+
+    void print(String type, Object printer, int index);
 }

engine/src/main/java/com/volmit/iris/platform/IrisPlatform.java

@@ -1,5 +1,6 @@
 package com.volmit.iris.platform;
 
+import java.io.File;
 import java.util.stream.Stream;
 
 public interface IrisPlatform {
@@ -21,4 +22,6 @@ public interface IrisPlatform {
     {
         return key("minecraft", nsk);
     }
+
+    File getStudioFolder(String dimension);
 }

engine/src/main/java/com/volmit/iris/platform/PlatformWorld.java

@@ -42,7 +42,9 @@ public interface PlatformWorld {
     }
 
     default File getIrisDataFolder() {
-        return new File(getWorldFolder("iris"), "data");
+        File f = new File(getWorldFolder("iris"), "data");
+        f.mkdirs();
+        return f;
     }
 
     default boolean isRegionLoaded(int x, int z) {