Synched & Linkable Custom Data

build.gradle

@@ -142,7 +142,7 @@ publishing {
     }
 }
 
-def gitBranch = 'git rev-parse --abbrev-ref HEAD'.execute().text.trim()
+def gitBranch = 'git rev-parse --abbrev-link HEAD'.execute().text.trim()
 
 tasks.processResources {
     filesMatching("*.properties") {

src/main/java/dev/amble/lib/AmbleKit.java

@@ -14,6 +14,7 @@
 public class AmbleKit implements ModInitializer {
     public static final String MOD_ID = "amblekit";
     public static final Logger LOGGER = LoggerFactory.getLogger(MOD_ID);
+    private static final boolean TESTS_ENABLED = true;
 
     @Override
     public void onInitialize() {
@@ -27,4 +28,7 @@ public void onInitialize() {
     public static Identifier id(String path) {
         return new Identifier(MOD_ID, path);
     }
+    public static boolean isTestingEnabled() {
+        return FabricLoader.getInstance().isDevelopmentEnvironment() && TESTS_ENABLED;
+    }
 }

src/main/java/dev/amble/lib/api/KitEvents.java

@@ -3,18 +3,33 @@
 import net.fabricmc.fabric.api.event.Event;
 import net.fabricmc.fabric.api.event.EventFactory;
 
+import net.minecraft.server.network.ServerPlayerEntity;
+import net.minecraft.world.chunk.WorldChunk;
+
 public class KitEvents {
     public static final Event<PreDatapackLoad> PRE_DATAPACK_LOAD = EventFactory.createArrayBacked(PreDatapackLoad.class, callbacks -> () -> {
         for (PreDatapackLoad callback : callbacks) {
             callback.load();
         }
     });
 
+    public static final Event<SyncRoot> SYNC_ROOT = EventFactory.createArrayBacked(SyncRoot.class,
+            callbacks -> (player, chunk) -> {
+                for (SyncRoot callback : callbacks) {
+                    callback.sync(player, chunk);
+                }
+            });
+
     /**
      * Called when just before datapacks are loaded
      */
     @FunctionalInterface
     public interface PreDatapackLoad {
         void load();
     }
+
+    @FunctionalInterface
+    public interface SyncRoot {
+        void sync(ServerPlayerEntity player, WorldChunk chunk);
+    }
 }

src/main/java/dev/amble/lib/api/sync/Disposable.java

@@ -0,0 +1,13 @@
+package dev.amble.lib.api.sync;
+
+public interface Disposable {
+
+    default void age() {
+    }
+
+    void dispose();
+
+    default boolean isAged() {
+        return false;
+    }
+}

src/main/java/dev/amble/lib/api/sync/Exclude.java

@@ -0,0 +1,16 @@
+package dev.amble.lib.api.sync;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target(ElementType.FIELD)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface Exclude {
+    Strategy strategy() default Strategy.ALL;
+
+    enum Strategy {
+        ALL, NETWORK, FILE
+    }
+}

src/main/java/dev/amble/lib/api/sync/Initializable.java

@@ -0,0 +1,50 @@
+package dev.amble.lib.api.sync;
+
+public abstract class Initializable<T extends Initializable.Context> {
+
+    public static <T extends Initializable.Context> void init(Initializable<T> component, T context) {
+        component.init(context);
+    }
+
+    protected void init(T context) {
+        this.onEarlyInit(context);
+
+        if (context.deserialized()) {
+            this.onLoaded();
+        } else {
+            this.onCreate();
+        }
+
+        this.onInit(context);
+    }
+
+    /**
+     * Called first in the initialization sequence.
+     */
+    protected void onEarlyInit(T ctx) {
+    }
+
+    /**
+     * Called after a {@link #onLoaded()} or {@link #onCreate()} is called.
+     */
+    protected void onInit(T ctx) {
+    }
+
+    /**
+     * Called when the component is created. Server-side only.
+     */
+    public void onCreate() {
+    }
+
+    /**
+     * Called when the component is loaded from a file or received on the client.
+     */
+    public void onLoaded() {
+    }
+
+    public interface Context {
+        boolean created();
+
+        boolean deserialized();
+    }
+}

src/main/java/dev/amble/lib/api/sync/RootComponent.java

@@ -0,0 +1,78 @@
+package dev.amble.lib.api.sync;
+
+import java.util.UUID;
+
+import net.fabricmc.api.EnvType;
+import net.fabricmc.api.Environment;
+
+import net.minecraft.client.MinecraftClient;
+import net.minecraft.server.MinecraftServer;
+
+import dev.amble.lib.AmbleKit;
+import dev.amble.lib.api.sync.handler.ComponentManager;
+import dev.amble.lib.api.sync.handler.SyncComponent;
+import dev.amble.lib.api.sync.handler.TickingComponent;
+import dev.amble.lib.api.sync.manager.SyncManager;
+
+public abstract class RootComponent extends Initializable<SyncComponent.InitContext> implements Disposable, TickingComponent {
+    private UUID uuid;
+    protected ComponentManager manager;
+
+    protected RootComponent(UUID uuid) {
+        this.uuid = uuid;
+        this.manager = new ComponentManager(getSyncManager().getHandlersId(), getSyncManager().getRegistry());
+    }
+
+    @Override
+    protected void onInit(SyncComponent.InitContext ctx) {
+        super.onInit(ctx);
+
+        SyncComponent.init(manager, this, ctx);
+
+        SyncComponent.postInit(manager, ctx);
+    }
+
+    public UUID getUuid() {
+        return uuid;
+    }
+
+    @Override
+    public String toString() {
+        return uuid.toString();
+    }
+
+    @Override
+    public int hashCode() {
+        return uuid.hashCode();
+    }
+
+    public <T extends SyncComponent> T handler(SyncComponent.IdLike type) {
+        if (this.manager == null) {
+            AmbleKit.LOGGER.error("Asked for a handler too early on {}", this);
+            return null;
+        }
+
+        return this.manager.get(type);
+    }
+
+    public ComponentManager getHandlers() {
+        return manager;
+    }
+    public abstract SyncManager<?, ?> getSyncManager();
+
+    @Override
+    public void dispose() {
+        this.getHandlers().dispose();
+    }
+
+    @Override
+    public void tick(MinecraftServer server) {
+        this.getHandlers().tick(server);
+    }
+
+    @Environment(EnvType.CLIENT)
+    @Override
+    public void tick(MinecraftClient client) {
+        this.getHandlers().tick(client) ;
+    }
+}