Add Codecs to serializable classes

.github/workflows/pr.yml

@@ -6,6 +6,12 @@ name: Build pull request
 on:
   pull_request:
   workflow_dispatch:
+  # trigger on pushes to the default branch (main) to keep the cache up to date
+  push:
+    branches: main
+
+env:
+  JAVA_VERSION: '17.0.1'
 
 jobs:
   build:
@@ -17,26 +23,57 @@ jobs:
       - uses: actions/setup-java@v4
         with:
           distribution: temurin
-          java-version: "17.0.1"
+          java-version: ${{ env.JAVA_VERSION }}
       - uses: gradle/actions/setup-gradle@v3
-      
-      - name: Clean
+
+      - name: Build
         run: |
           chmod +x gradlew
-          ./gradlew clean
+          ./gradlew build
 
-      - name: Build
-        run: ./gradlew build
+      - name: Prepare artifacts for upload
+        run: |
+          mkdir -p dist
+          cp {Common,Forge,Fabric}/build/libs/*.jar dist
 
-      - name: Run Datagen
-        run: ./gradlew runAllDatagen
+      - name: Upload artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: mod-build
+          path: dist
+          retention-days: 30
+
+  datagen:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - uses: actions/setup-java@v4
+        with:
+          distribution: temurin
+          java-version: ${{ env.JAVA_VERSION }}
+      - uses: gradle/actions/setup-gradle@v3
+
+      # ForgeGradle datagen asset download often fails (see #692)
+      # so just allow it to automatically retry a few times
+      - name: Run datagen
+        uses: nick-fields/retry@v3
+        with:
+          timeout_minutes: 10
+          max_attempts: 3
+          command: |
+            chmod +x gradlew
+            ./gradlew runAllDatagen
 
-      - name: Check Datagen
+      - name: Check datagen
         run: |
           git add --intent-to-add .
           git diff --name-only --exit-code -- ":!:*/src/generated/resources/.cache/*"
 
   hexdoc:
+    # don't bother running the docs build when pushing to main - nothing necessary to cache here
+    if: github.event_name != 'push'
     uses: hexdoc-dev/hexdoc/.github/workflows/hexdoc.yml@main
     permissions:
       contents: write

Common/src/main/resources/data/hexcasting/damage_type/overcast.json → Common/src/generated/resources/data/hexcasting/damage_type/overcast.json

@@ -1,5 +1,5 @@
 {
-  "exhaustion": 0,
+  "exhaustion": 0.0,
   "message_id": "hexcasting.overcast",
   "scaling": "when_caused_by_living_non_player"
 }

Common/src/generated/resources/data/minecraft/tags/damage_type/bypasses_armor.json

@@ -0,0 +1,5 @@
+{
+  "values": [
+    "hexcasting:overcast"
+  ]
+}

Common/src/generated/resources/data/minecraft/tags/damage_type/bypasses_effects.json

@@ -0,0 +1,5 @@
+{
+  "values": [
+    "hexcasting:overcast"
+  ]
+}

Common/src/generated/resources/data/minecraft/tags/damage_type/bypasses_shield.json

@@ -0,0 +1,5 @@
+{
+  "values": [
+    "hexcasting:overcast"
+  ]
+}

Common/src/main/java/at/petrak/hexcasting/api/addldata/ADIotaHolder.java

@@ -2,6 +2,7 @@
 
 import at.petrak.hexcasting.api.casting.iota.Iota;
 import at.petrak.hexcasting.api.casting.iota.IotaType;
+import at.petrak.hexcasting.api.utils.HexUtils;
 import net.minecraft.nbt.CompoundTag;
 import net.minecraft.server.level.ServerLevel;
 import org.jetbrains.annotations.Nullable;
@@ -14,7 +15,7 @@ public interface ADIotaHolder {
     default Iota readIota(ServerLevel world) {
         var tag = readIotaTag();
         if (tag != null) {
-            return IotaType.deserialize(tag, world);
+            return HexUtils.deserializeWithCodec(tag, Iota.getCodec(world));
         } else {
             return null;
         }
@@ -29,4 +30,9 @@ default Iota emptyIota() {
      * @return if the writing succeeded/would succeed
      */
     boolean writeIota(@Nullable Iota iota, boolean simulate);
+
+    /**
+     * @return whether it is possible to write to this IotaHolder
+     */
+    boolean writeable();
 }

Common/src/main/java/at/petrak/hexcasting/api/addldata/ItemDelegatingEntityIotaHolder.java

@@ -29,6 +29,12 @@ public ItemDelegatingEntityIotaHolder(Supplier<ItemStack> stackSupplier, Consume
         return delegate == null ? null : delegate.readIotaTag();
     }
 
+    @Override
+    public boolean writeable() {
+        var delegate = IXplatAbstractions.INSTANCE.findDataHolder(this.stackSupplier.get());
+        return delegate != null && delegate.writeable();
+    }
+
     @Override
     public boolean writeIota(@Nullable Iota datum, boolean simulate) {
         var stacc = this.stackSupplier.get();

Common/src/main/java/at/petrak/hexcasting/api/advancements/MinMaxLongs.java

@@ -0,0 +1,85 @@
+package at.petrak.hexcasting.api.advancements;
+
+import com.google.gson.JsonElement;
+import com.mojang.brigadier.StringReader;
+import com.mojang.brigadier.exceptions.BuiltInExceptionProvider;
+import com.mojang.brigadier.exceptions.CommandSyntaxException;
+import net.minecraft.advancements.critereon.MinMaxBounds;
+import net.minecraft.util.GsonHelper;
+
+import javax.annotation.Nullable;
+import java.util.Objects;
+import java.util.function.Function;
+
+public class MinMaxLongs extends MinMaxBounds<Long> {
+    public static final MinMaxLongs ANY = new MinMaxLongs(null, null);
+    @Nullable
+    private final Long minSq;
+    @Nullable
+    private final Long maxSq;
+
+    private static MinMaxLongs create(StringReader reader, @Nullable Long min, @Nullable Long max) throws CommandSyntaxException {
+        if (min != null && max != null && min > max) {
+            throw ERROR_SWAPPED.createWithContext(reader);
+        } else {
+            return new MinMaxLongs(min, max);
+        }
+    }
+
+    @Nullable
+    private static Long squareOpt(@Nullable Long l) {
+        return l == null ? null : l * l;
+    }
+
+    private MinMaxLongs(@Nullable Long min, @Nullable Long max) {
+        super(min, max);
+        this.minSq = squareOpt(min);
+        this.maxSq = squareOpt(max);
+    }
+
+    public static MinMaxLongs exactly(long l) {
+        return new MinMaxLongs(l, l);
+    }
+
+    public static MinMaxLongs between(long min, long max) {
+        return new MinMaxLongs(min, max);
+    }
+
+    public static MinMaxLongs atLeast(long min) {
+        return new MinMaxLongs(min, null);
+    }
+
+    public static MinMaxLongs atMost(long max) {
+        return new MinMaxLongs(null, max);
+    }
+
+    public boolean matches(long l) {
+        if (this.min != null && this.min > l) {
+            return false;
+        } else {
+            return this.max == null || this.max >= l;
+        }
+    }
+
+    public boolean matchesSqr(long l) {
+        if (this.minSq != null && this.minSq > l) {
+            return false;
+        } else {
+            return this.maxSq == null || this.maxSq >= l;
+        }
+    }
+
+    public static MinMaxLongs fromJson(@Nullable JsonElement json) {
+        return fromJson(json, ANY, GsonHelper::convertToLong, MinMaxLongs::new);
+    }
+
+    public static MinMaxLongs fromReader(StringReader reader) throws CommandSyntaxException {
+        return fromReader(reader, (l) -> l);
+    }
+
+    public static MinMaxLongs fromReader(StringReader reader, Function<Long, Long> map) throws CommandSyntaxException {
+        BuiltInExceptionProvider builtInExceptions = CommandSyntaxException.BUILT_IN_EXCEPTIONS;
+        Objects.requireNonNull(builtInExceptions);
+        return fromReader(reader, MinMaxLongs::create, Long::parseLong, builtInExceptions::readerInvalidInt, map);
+    }
+}

Common/src/main/java/at/petrak/hexcasting/api/advancements/SpendMediaTrigger.java

@@ -20,20 +20,20 @@ public ResourceLocation getId() {
     protected Instance createInstance(JsonObject json, ContextAwarePredicate predicate,
         DeserializationContext context) {
         return new Instance(predicate,
-            MinMaxBounds.Ints.fromJson(json.get(TAG_MEDIA_SPENT)),
-            MinMaxBounds.Ints.fromJson(json.get(TAG_MEDIA_WASTED)));
+            MinMaxLongs.fromJson(json.get(TAG_MEDIA_SPENT)),
+            MinMaxLongs.fromJson(json.get(TAG_MEDIA_WASTED)));
     }
 
-    public void trigger(ServerPlayer player, int mediaSpent, int mediaWasted) {
+    public void trigger(ServerPlayer player, long mediaSpent, long mediaWasted) {
         super.trigger(player, inst -> inst.test(mediaSpent, mediaWasted));
     }
 
     public static class Instance extends AbstractCriterionTriggerInstance {
-        protected final MinMaxBounds.Ints mediaSpent;
-        protected final MinMaxBounds.Ints mediaWasted;
+        protected final MinMaxLongs mediaSpent;
+        protected final MinMaxLongs mediaWasted;
 
-        public Instance(ContextAwarePredicate predicate, MinMaxBounds.Ints mediaSpent,
-            MinMaxBounds.Ints mediaWasted) {
+        public Instance(ContextAwarePredicate predicate, MinMaxLongs mediaSpent,
+            MinMaxLongs mediaWasted) {
             super(SpendMediaTrigger.ID, predicate);
             this.mediaSpent = mediaSpent;
             this.mediaWasted = mediaWasted;
@@ -56,7 +56,7 @@ public JsonObject serializeToJson(SerializationContext ctx) {
             return json;
         }
 
-        private boolean test(int mediaSpentIn, int mediaWastedIn) {
+        private boolean test(long mediaSpentIn, long mediaWastedIn) {
             return this.mediaSpent.matches(mediaSpentIn) && this.mediaWasted.matches(mediaWastedIn);
         }
     }

Common/src/main/java/at/petrak/hexcasting/api/casting/ActionUtils.kt

@@ -4,11 +4,13 @@ package at.petrak.hexcasting.api.casting
 
 import at.petrak.hexcasting.api.casting.iota.*
 import at.petrak.hexcasting.api.casting.math.HexPattern
+import at.petrak.hexcasting.api.casting.mishaps.MishapEntityNotFound
 import at.petrak.hexcasting.api.casting.mishaps.MishapInvalidIota
 import at.petrak.hexcasting.api.casting.mishaps.MishapNotEnoughArgs
 import at.petrak.hexcasting.api.utils.asTranslatedComponent
 import com.mojang.datafixers.util.Either
 import net.minecraft.core.BlockPos
+import net.minecraft.server.level.ServerLevel
 import net.minecraft.server.level.ServerPlayer
 import net.minecraft.world.entity.Entity
 import net.minecraft.world.entity.LivingEntity
@@ -32,10 +34,10 @@ fun List<Iota>.getDouble(idx: Int, argc: Int = 0): Double {
     }
 }
 
-fun List<Iota>.getEntity(idx: Int, argc: Int = 0): Entity {
+fun List<Iota>.getEntity(idx: Int, argc: Int = 0, world: ServerLevel): Entity {
     val x = this.getOrElse(idx) { throw MishapNotEnoughArgs(idx + 1, this.size) }
     if (x is EntityIota) {
-        return x.entity
+        return x.getEntity(world)?: throw MishapEntityNotFound(x, if (argc == 0) idx else argc - (idx + 1))
     } else {
         throw MishapInvalidIota.ofType(x, if (argc == 0) idx else argc - (idx + 1), "entity")
     }
@@ -79,40 +81,40 @@ fun List<Iota>.getBool(idx: Int, argc: Int = 0): Boolean {
 
 // Helpers
 
-fun List<Iota>.getItemEntity(idx: Int, argc: Int = 0): ItemEntity {
+fun List<Iota>.getItemEntity(idx: Int, argc: Int = 0, world: ServerLevel): ItemEntity {
     val x = this.getOrElse(idx) { throw MishapNotEnoughArgs(idx + 1, this.size) }
     if (x is EntityIota) {
-        val e = x.entity
+        val e = x.getEntity(world)?: throw MishapEntityNotFound(x, if (argc == 0) idx else argc - (idx + 1))
         if (e is ItemEntity)
             return e
     }
     throw MishapInvalidIota.ofType(x, if (argc == 0) idx else argc - (idx + 1), "entity.item")
 }
 
-fun List<Iota>.getPlayer(idx: Int, argc: Int = 0): ServerPlayer {
+fun List<Iota>.getPlayer(idx: Int, argc: Int = 0, world: ServerLevel): ServerPlayer {
     val x = this.getOrElse(idx) { throw MishapNotEnoughArgs(idx + 1, this.size) }
     if (x is EntityIota) {
-        val e = x.entity
+        val e = x.getEntity(world)?: throw MishapEntityNotFound(x, if (argc == 0) idx else argc - (idx + 1))
         if (e is ServerPlayer)
             return e
     }
     throw MishapInvalidIota.ofType(x, if (argc == 0) idx else argc - (idx + 1), "entity.player")
 }
 
-fun List<Iota>.getMob(idx: Int, argc: Int = 0): Mob {
+fun List<Iota>.getMob(idx: Int, argc: Int = 0, world: ServerLevel): Mob {
     val x = this.getOrElse(idx) { throw MishapNotEnoughArgs(idx + 1, this.size) }
     if (x is EntityIota) {
-        val e = x.entity
+        val e = x.getEntity(world)?: throw MishapEntityNotFound(x, if (argc == 0) idx else argc - (idx + 1))
         if (e is Mob)
             return e
     }
     throw MishapInvalidIota.ofType(x, if (argc == 0) idx else argc - (idx + 1), "entity.mob")
 }
 
-fun List<Iota>.getLivingEntityButNotArmorStand(idx: Int, argc: Int = 0): LivingEntity {
+fun List<Iota>.getLivingEntityButNotArmorStand(idx: Int, argc: Int = 0, world: ServerLevel): LivingEntity {
     val x = this.getOrElse(idx) { throw MishapNotEnoughArgs(idx + 1, this.size) }
     if (x is EntityIota) {
-        val e = x.entity
+        val e = x.getEntity(world)?: throw MishapEntityNotFound(x, if (argc == 0) idx else argc - (idx + 1))
         if (e is LivingEntity && e !is ArmorStand)
             return e
     }

Common/src/main/java/at/petrak/hexcasting/api/casting/SpellList.kt

@@ -1,6 +1,9 @@
 package at.petrak.hexcasting.api.casting
 
 import at.petrak.hexcasting.api.casting.iota.Iota
+import com.mojang.serialization.Codec
+import net.minecraft.server.level.ServerLevel
+import java.util.Collections
 
 /**
  * Restricted interface for functional lists.
@@ -90,4 +93,12 @@ sealed class SpellList : Iterable<Iota> {
             return car
         }
     }
+
+    companion object {
+        @JvmStatic
+        fun getCodec(): Codec<SpellList> = Iota.getCodec().listOf().xmap(SpellList::LList, SpellList::toMutableList)
+
+        @JvmStatic
+        fun getCodec(world: ServerLevel): Codec<SpellList> = Iota.getCodec(world).listOf().xmap(SpellList::LList, SpellList::toMutableList)
+    }
 }

Common/src/main/java/at/petrak/hexcasting/api/casting/castables/OperationAction.kt

@@ -18,7 +18,7 @@ data class OperationAction(val pattern: HexPattern) : Action {
         return try {
             HexArithmetics.getEngine().run(pattern, env, image, continuation)
         } catch (e: NoOperatorCandidatesException) {
-            throw MishapInvalidOperatorArgs(e.args, e.pattern)
+            throw MishapInvalidOperatorArgs(e.args)
         }
     }
 }

Common/src/main/java/at/petrak/hexcasting/api/casting/circles/CircleExecutionState.java

@@ -237,6 +237,9 @@ public boolean tick(BlockEntityAbstractImpetus impetus) {
         var ctrl = executor.acceptControlFlow(this.currentImage, env, this.enteredFrom, this.currentPos,
             executorBlockState, world);
 
+        if (env.getImpetus() == null)
+            return false; //the impetus got removed during the cast and no longer exists in the world. stop casting
+
         if (ctrl instanceof ICircleComponent.ControlFlow.Stop) {
             // acceptControlFlow should have already posted the error
             halt = true;