Back to the Future

Fun is still suspended though

src/main/java/io/github/skippyall/minions/minion/MinionData.kt

@@ -1,58 +1,82 @@
-package io.github.skippyall.minions.minion;
+package io.github.skippyall.minions.minion
 
-import com.mojang.authlib.properties.PropertyMap;
-import com.mojang.serialization.Codec;
-import com.mojang.serialization.codecs.RecordCodecBuilder;
-import io.github.skippyall.minions.listener.SerializableListenerManager;
-import io.github.skippyall.minions.registration.MinionRegistries;
-import net.minecraft.core.UUIDUtil;
-import net.minecraft.server.MinecraftServer;
-import net.minecraft.util.ExtraCodecs;
-import java.util.Optional;
-import java.util.UUID;
+import com.mojang.authlib.properties.PropertyMap
+import com.mojang.serialization.Codec
+import com.mojang.serialization.codecs.RecordCodecBuilder
+import io.github.skippyall.minions.listener.SerializableListenerManager
+import io.github.skippyall.minions.registration.MinionRegistries
+import net.minecraft.core.UUIDUtil
+import net.minecraft.server.MinecraftServer
+import net.minecraft.util.ExtraCodecs
+import java.util.Optional
+import java.util.UUID
+import kotlin.properties.ReadWriteProperty
+import kotlin.reflect.KProperty
 
-public record MinionData(
-        UUID uuid,
-        String name,
-        Optional<PropertyMap> skin,
-        boolean isSpawned,
-        SerializableListenerManager<MinionListener> listeners,
-        MinionConfig config
+class MinionData(
+    initialUuid: UUID,
+    initialName: String,
+    initialSkin: Optional<PropertyMap>,
+    initialIsSpawned: Boolean,
+    val listeners: SerializableListenerManager<MinionListener>,
+    initialConfig: MinionConfig,
+    var onDirty: Runnable = {},
 ) {
-    public static final Codec<MinionData> CODEC = RecordCodecBuilder.create(instance ->
-            instance.group(
+    var uuid by DirtyProperty(initialUuid, this::setDirty)
+    var name by DirtyProperty(initialName, this::setDirty)
+    var skin by DirtyProperty(initialSkin, this::setDirty)
+    var isSpawned by DirtyProperty(initialIsSpawned, this::setDirty)
+    var config by DirtyProperty(initialConfig, this::setDirty)
+
+    fun setDirty() {
+        this@MinionData.onDirty.run()
+    }
+
+    companion object {
+        @JvmField
+        val CODEC: Codec<MinionData> =
+            RecordCodecBuilder.create { instance ->
+                instance.group(
                     UUIDUtil.AUTHLIB_CODEC.fieldOf("uuid").forGetter(MinionData::uuid),
                     Codec.STRING.fieldOf("name").forGetter(MinionData::name),
                     ExtraCodecs.PROPERTY_MAP.optionalFieldOf("skin").forGetter(MinionData::skin),
                     Codec.BOOL.optionalFieldOf("isSpawned", false).forGetter(MinionData::isSpawned),
-                    SerializableListenerManager.getCodec(MinionRegistries.MINION_LISTENER_CODECS).optionalFieldOf("listeners").xmap(
-                            optional -> optional.orElseGet(SerializableListenerManager::new),
-                            Optional::of
-                    ).forGetter(MinionData::listeners),
-                    MinionConfig.CODEC.optionalFieldOf("config", new MinionConfig()).forGetter(MinionData::config)
-            ).apply(instance, MinionData::new)
-    );
+                    SerializableListenerManager.getCodec<MinionListener>(MinionRegistries.MINION_LISTENER_CODECS)
+                            .optionalFieldOf("listeners").xmap(
+                                { optional -> optional.orElseGet { SerializableListenerManager() } },
+                                Optional<SerializableListenerManager<MinionListener>>::of
+                            ).forGetter(MinionData::listeners),
+                    MinionConfig.CODEC.optionalFieldOf("config", MinionConfig())
+                            .forGetter(MinionData::config)
+                ).apply(
+                    instance,
+                    ::MinionData
+                )
+            }
 
-    public static MinionData createDefault(MinecraftServer server) {
-        return new MinionData(
+        @JvmStatic
+        fun createDefault(server: MinecraftServer): MinionData {
+            return MinionData(
                 UUID.randomUUID(),
                 MinionProfileUtils.newDefaultMinionName(server),
-                Optional.empty(),
+                Optional.empty<PropertyMap>(),
                 false,
-                new SerializableListenerManager<>(),
-                new MinionConfig()
-        );
+                SerializableListenerManager(),
+                MinionConfig()
+            ) {
+                MinionPersistentState.get(server).isDirty = true
+            }
+        }
     }
 
-    public MinionData withName(String name) {
-        return new MinionData(uuid, name, skin, isSpawned, listeners, config);
-    }
+    class DirtyProperty<V>(var value: V, val onDirty: () -> Unit) : ReadWriteProperty<Any?, V> {
+        override fun getValue(thisRef: Any?, property: KProperty<*>): V {
+            return value
+        }
 
-    public MinionData withSkin(Optional<PropertyMap> skin) {
-        return new MinionData(uuid, name, skin, isSpawned, listeners, config);
-    }
-
-    public MinionData withSpawned(boolean isSpawned) {
-        return new MinionData(uuid, name, skin, isSpawned, listeners, config);
+        override fun setValue(thisRef: Any?, property: KProperty<*>, value: V) {
+            this.value = value
+            onDirty()
+        }
     }
 }