Serializers and tests

Author: Intybyte

api-internal/pom.xml

@@ -16,6 +16,16 @@
     </properties>
 
     <dependencies>
+        <dependency>
+            <groupId>org.spongepowered</groupId>
+            <artifactId>configurate-core</artifactId>
+            <version>4.2.0</version>
+        </dependency>
+        <dependency>
+            <groupId>org.spongepowered</groupId>
+            <artifactId>configurate-yaml</artifactId>
+            <version>4.2.0</version>
+        </dependency>
         <dependency>
             <groupId>com.google.code.gson</groupId>
             <artifactId>gson</artifactId>
@@ -33,6 +43,20 @@
             <version>1.18.30</version>
             <scope>provided</scope>
         </dependency>
+
+        <!-- Testing dependencies  -->
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter</artifactId>
+            <version>5.11.4</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.mockito</groupId>
+            <artifactId>mockito-core</artifactId>
+            <version>5.18.0</version>
+            <scope>test</scope>
+        </dependency>
     </dependencies>
 
     <build>

api-internal/src/main/java/at/pavlov/internal/adapters/CannonSerializingManager.java

@@ -0,0 +1,12 @@
+package at.pavlov.internal.adapters;
+
+import at.pavlov.internal.Key;
+import at.pavlov.internal.projectile.definition.CustomProjectileDefinition;
+import org.spongepowered.configurate.serialize.TypeSerializerCollection;
+
+public class CannonSerializingManager {
+    public static final TypeSerializerCollection serializerCollection = TypeSerializerCollection.defaults().childBuilder()
+            .register(Key.class, new KeySerializer())
+            .register(CustomProjectileDefinition.class, new CustomProjectileDefinitionSerializer())
+            .build();
+}

api-internal/src/main/java/at/pavlov/internal/adapters/CustomProjectileDefinitionSerializer.java

@@ -0,0 +1,51 @@
+package at.pavlov.internal.adapters;
+
+import at.pavlov.internal.Key;
+import at.pavlov.internal.key.registries.Registries;
+import at.pavlov.internal.projectile.definition.CustomProjectileDefinition;
+import at.pavlov.internal.projectile.definition.ProjectilePhysics;
+import org.jetbrains.annotations.NotNull;
+import org.spongepowered.configurate.ConfigurationNode;
+import org.spongepowered.configurate.serialize.SerializationException;
+import org.spongepowered.configurate.serialize.TypeSerializer;
+
+import java.lang.reflect.Type;
+
+public class CustomProjectileDefinitionSerializer implements TypeSerializer<CustomProjectileDefinition> {
+
+    @Override
+    public CustomProjectileDefinition deserialize(@NotNull Type type, ConfigurationNode node) throws SerializationException {
+        // Use the node's key as the projectile key
+        Key key = Key.from(node.key().toString()); // top-level key
+        Key entityKey = Key.from(node.node("entity").getString("SNOWBALL"));
+
+        // Get default projectile physics if entityKey not registered
+        ProjectilePhysics dpd = Registries.DEFAULT_PROJECTILE_DEFINITION_REGISTRY.of(entityKey);
+        if (dpd == null) {
+            dpd = ProjectilePhysics.DEFAULT;
+        }
+
+        // Build the CustomProjectileDefinition
+        return CustomProjectileDefinition.builder()
+                .key(key)
+                .entityKey(entityKey)
+                .constantAcceleration(node.node("constantAcceleration").get(Double.class, dpd.getConstantAcceleration()))
+                .gravity(node.node("gravity").getDouble(dpd.getGravity()))
+                .drag(node.node("drag").getDouble(dpd.getDrag()))
+                .waterDrag(node.node("waterDrag").getDouble(dpd.getWaterDrag()))
+                .glowing(node.node("glowing").getBoolean(false))
+                .onFire(node.node("onFire").getBoolean(false))
+                .charged(node.node("charged").getBoolean(false))
+                .critical(node.node("critical").getBoolean(false))
+                .material(Key.from(node.node("material").getString("SNOWBALL")))
+                .customModelData(node.node("customModelData").get(Integer.class, (Integer) null))
+                .build();
+    }
+
+    @Override
+    public void serialize(@NotNull Type type, CustomProjectileDefinition obj, @NotNull ConfigurationNode node) throws SerializationException {
+        // Not needed, can throw UnsupportedOperationException if you never serialize
+        throw new UnsupportedOperationException("Serialization not supported for this deserializer");
+    }
+}
+

api-internal/src/main/java/at/pavlov/internal/adapters/KeySerializer.java

@@ -0,0 +1,28 @@
+package at.pavlov.internal.adapters;
+
+import at.pavlov.internal.Key;
+import org.jetbrains.annotations.NotNull;
+import org.spongepowered.configurate.ConfigurationNode;
+import org.spongepowered.configurate.serialize.SerializationException;
+import org.spongepowered.configurate.serialize.TypeSerializer;
+
+import java.lang.reflect.Type;
+
+public class KeySerializer implements TypeSerializer<Key> {
+
+    @Override
+    public Key deserialize(@NotNull Type type, ConfigurationNode node) throws SerializationException {
+        String value = node.getString();
+        if (value == null || !value.contains(":")) {
+            throw new SerializationException("Invalid Key format, expected namespace:key");
+        }
+        String[] parts = value.split(":", 2);
+        return new Key(parts[0], parts[1]);
+    }
+
+    @Override
+    public void serialize(@NotNull Type type, Key obj, @NotNull ConfigurationNode node) throws SerializationException {
+        if (obj == null) return;
+        node.set(obj.full());
+    }
+}

api-internal/src/main/java/at/pavlov/internal/projectile/definition/CustomProjectileDefinition.java

@@ -1,56 +1,33 @@
 package at.pavlov.internal.projectile.definition;
 
 import at.pavlov.internal.Key;
-import lombok.AllArgsConstructor;
-import lombok.Builder;
-import lombok.Getter;
+import lombok.*;
 import org.jetbrains.annotations.Nullable;
+import org.spongepowered.configurate.objectmapping.ConfigSerializable;
 
 @Getter
 @Builder
+@EqualsAndHashCode
+@ConfigSerializable
+@NoArgsConstructor
 @AllArgsConstructor
 public class CustomProjectileDefinition implements ProjectilePhysics {
-    private final Key key; // for the name of the custom projectile definition
-    private final Key entityKey;
+    private Key key; // for the name of the custom projectile definition
+    private Key entityKey;
 
-    private final Double constantAcceleration;
+    private Double constantAcceleration;
 
-    private final double gravity;
-    private final double drag;
-    private final double waterDrag;
+    private double gravity;
+    private double drag;
+    private double waterDrag;
 
-    private final boolean glowing;
+    private boolean glowing;
 
-    private final boolean onFire; // visual fire for projectile
-    private final boolean charged; // works for wither skeletons
-    private final boolean critical; // for arrows and tridents
+    private boolean onFire; // visual fire for projectile
+    private boolean charged; // works for wither skeletons
+    private boolean critical; // for arrows and tridents
 
     //for throwable projectiles only
-    private final @Nullable Key material;
-    private final @Nullable Integer customModelData;
-
-    /*
-    @Override
-    public double getGravity() {
-        return fromKey().getGravity();
-    }
-
-    @Override
-    public double getDrag() {
-        return fromKey().getDrag();
-    }
-
-    @Override
-    public double getWaterDrag() {
-        return fromKey().getWaterDrag();
-    }
-
-    private @NotNull ProjectilePhysics fromKey() {
-        DefaultProjectileDefinition value = Registries.DEFAULT_PROJECTILE_DEFINITION_REGISTRY.of(entityKey);
-        if (value == null) {
-            return ProjectilePhysics.DEFAULT;
-        }
-
-        return value;
-    }*/
+    private @Nullable Key material;
+    private @Nullable Integer customModelData;
 }

api-internal/src/main/java/at/pavlov/internal/projectile/definition/DefaultProjectileDefinition.java

@@ -1,20 +1,22 @@
 package at.pavlov.internal.projectile.definition;
 
 import at.pavlov.internal.Key;
-import lombok.AllArgsConstructor;
-import lombok.Builder;
-import lombok.Getter;
+import lombok.*;
 import org.jetbrains.annotations.NotNull;
+import org.spongepowered.configurate.objectmapping.ConfigSerializable;
 
 @Getter
 @Builder
+@ConfigSerializable
+@EqualsAndHashCode
+@NoArgsConstructor
 @AllArgsConstructor
 public class DefaultProjectileDefinition implements ProjectilePhysics {
-    private final @NotNull Key key; // for the entity type
-    private final Double constantAcceleration;
-    private final double gravity;
-    private final double drag;
-    private final double waterDrag;
+    private @NotNull Key key; // for the entity type
+    private Double constantAcceleration;
+    private double gravity;
+    private double drag;
+    private double waterDrag;
 
     @Override
     public Key getEntityKey() {

api-internal/src/test/java/adapters/BuilderTypeSerializerTest.java

@@ -0,0 +1,52 @@
+package adapters;
+
+import at.pavlov.internal.Key;
+import at.pavlov.internal.adapters.CannonSerializingManager;
+import at.pavlov.internal.projectile.definition.DefaultProjectileDefinition;
+import org.junit.jupiter.api.Test;
+import org.spongepowered.configurate.ConfigurationNode;
+import org.spongepowered.configurate.yaml.YamlConfigurationLoader;
+
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
+public class BuilderTypeSerializerTest {
+
+    @Test
+    void testBuilderSerialization() throws Exception {
+        // Create temp file for YAML loader
+        Path tempFile = Files.createTempFile("test", ".yml");
+
+        // Create YAML loader with custom serializers
+        YamlConfigurationLoader loader = YamlConfigurationLoader.builder()
+                .path(tempFile)
+                .defaultOptions(options -> options.serializers(CannonSerializingManager.serializerCollection))
+                .build();
+
+        // Create an instance using the builder
+        DefaultProjectileDefinition original = DefaultProjectileDefinition.builder()
+                .key(Key.mc("test"))
+                .drag(2.1)
+                .constantAcceleration(1.2)
+                .waterDrag(2.4)
+                .gravity(-1.4)
+                .build();
+
+        // Serialize to a ConfigurationNode
+        ConfigurationNode node = loader.createNode();
+        node.set(original);
+
+        // Optionally, print YAML for debugging
+        System.out.println(node);
+
+        // Deserialize back
+        DefaultProjectileDefinition deserialized = node.get(DefaultProjectileDefinition.class);
+
+        // Basic assertions
+        assertNotNull(deserialized, "Deserialized object should not be null");
+        assertEquals(original, deserialized, "Deserialized object should be equal to original");
+    }
+}