Add mishap-detection pattern (#1194)

Adds a system for mishap prevention by simulating patterns to see
whether they'd mishap without having to actually cast them. Also removes
the assessor/auditor patterns, since this makes them obsolete.

<img width="862" height="562" alt="image"
src="https://github.com/user-attachments/assets/e508c52e-627a-4dbf-99bd-2b1ce5ab7343"
/>

Author: Robotgiggle

CHANGELOG.md

@@ -9,6 +9,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 ### Added
 
 - Updated to Minecraft 1.21.1 ([#985](https://github.com/FallingColors/HexMod/pull/985)) @SuperKnux @slava110
+- Added Simulate, which causes the next pattern drawn to be simulated (to check for mishaps) rather than executed ([#1194](https://github.com/FallingColors/HexMod/pull/1194)) @Robotgiggle
 - Added the `hex_unbreakable` tag for blocks that should be immune to Break Block regardless of the configured mining tier ([#1186](https://github.com/FallingColors/HexMod/pull/1186)) @Robotgiggle @slava110
 
 ### Fixed

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

@@ -6,6 +6,7 @@ enum class ResolvedPatternType(val color: Int, val fadeColor: Int, val success:
     UNRESOLVED(0x7f7f7f, 0xcccccc, false),
     EVALUATED(0x7385de, 0xfecbe6, true),
     ESCAPED(0xddcc73, 0xfffae5, true),
+    SIMULATED(0xed9d64, 0xffecde, true),
     UNDONE(0xb26b6b, 0xcca88e, true), // TODO: Pick better colours
     ERRORED(0xde6262, 0xffc7a0, false),
     INVALID(0xb26b6b, 0xcca88e, false);

Common/src/main/java/at/petrak/hexcasting/api/casting/eval/vm/CastingImage.kt

@@ -5,6 +5,7 @@ import at.petrak.hexcasting.api.casting.iota.Iota
 import at.petrak.hexcasting.api.casting.iota.IotaType
 import at.petrak.hexcasting.api.utils.getOrCreateCompound
 import at.petrak.hexcasting.api.utils.putCompound
+import at.petrak.hexcasting.api.utils.compositeCodecSeven
 import com.mojang.serialization.Codec
 import com.mojang.serialization.codecs.RecordCodecBuilder
 import net.minecraft.nbt.CompoundTag
@@ -22,10 +23,11 @@ data class CastingImage(
     val parenCount: Int,
     val parenthesized: List<ParenthesizedIota>,
     val escapeNext: Boolean,
+    val simulateNext: Boolean,
     val opsConsumed: Long,
     val userData: CompoundTag
 ) {
-    constructor() : this(listOf(), 0, listOf(), false, 0, CompoundTag())
+    constructor() : this(listOf(), 0, listOf(), false, false, 0, CompoundTag())
 
     /**
      * `escaped` is used by [OpUndo][at.petrak.hexcasting.common.casting.actions.escaping.OpUndo] to determine whether the paren count
@@ -95,22 +97,24 @@ data class CastingImage(
                 Codec.INT.fieldOf("open_parens").forGetter { it.parenCount },
                 ParenthesizedIota.CODEC.listOf().fieldOf("parenthesized").forGetter { it.parenthesized },
                 Codec.BOOL.fieldOf("escape_next").forGetter { it.escapeNext },
+                Codec.BOOL.fieldOf("simulate_next").forGetter { it.simulateNext },
                 Codec.LONG.fieldOf("ops_consumed").forGetter { it.opsConsumed },
                 CompoundTag.CODEC.fieldOf("userData").forGetter { it.userData }
-            ).apply(inst) { a, b, c, d, e, f ->
-                CastingImage(a, b, c, d, e, f)
+            ).apply(inst) { a, b, c, d, e, f, g ->
+                CastingImage(a, b, c, d, e, f, g)
             }
         }.orElseGet(::CastingImage)
         @JvmStatic
-        val STREAM_CODEC = StreamCodec.composite(
+        val STREAM_CODEC = compositeCodecSeven(
             IotaType.TYPED_STREAM_CODEC.apply(ByteBufCodecs.list()), CastingImage::stack,
             ByteBufCodecs.VAR_INT, CastingImage::parenCount,
             ParenthesizedIota.STREAM_CODEC.apply(ByteBufCodecs.list()), CastingImage::parenthesized,
             ByteBufCodecs.BOOL, CastingImage::escapeNext,
+            ByteBufCodecs.BOOL, CastingImage::simulateNext,
             ByteBufCodecs.VAR_LONG, CastingImage::opsConsumed,
             ByteBufCodecs.COMPOUND_TAG, { it.userData },
-            { a, b, c, d, e, f ->
-                        CastingImage(a, b, c, d, e, f)
+            { a, b, c, d, e, f, g ->
+                        CastingImage(a, b, c, d, e, f, g)
                     }
         )
 

Common/src/main/java/at/petrak/hexcasting/api/casting/eval/vm/CastingVM.kt

@@ -5,6 +5,7 @@ import at.petrak.hexcasting.api.casting.SpellList
 import at.petrak.hexcasting.api.casting.eval.*
 import at.petrak.hexcasting.api.casting.eval.sideeffects.OperatorSideEffect
 import at.petrak.hexcasting.api.casting.eval.vm.CastingImage.ParenthesizedIota
+import at.petrak.hexcasting.api.casting.iota.BooleanIota
 import at.petrak.hexcasting.api.casting.iota.Iota
 import at.petrak.hexcasting.api.casting.iota.IotaType
 import at.petrak.hexcasting.api.casting.iota.ListIota
@@ -111,7 +112,11 @@ class CastingVM(var image: CastingImage, val env: CastingEnvironment) {
             ravenmind = IotaType.TYPED_CODEC.encodeStart<Tag?>(NbtOps.INSTANCE, newIota).getOrThrow() as CompoundTag?
         }
 
-        val isStackClear = image.stack.isEmpty() && image.parenCount == 0 && !image.escapeNext && ravenmind == null
+        val isStackClear = image.stack.isEmpty()
+                        && image.parenCount == 0
+                        && !image.escapeNext
+                        && !image.simulateNext
+                        && ravenmind == null
 
         this.env.postCast(image)
         return ExecutionClientView(isStackClear, lastResolutionType, image.stack, ravenmind)
@@ -150,13 +155,28 @@ class CastingVM(var image: CastingImage, val env: CastingEnvironment) {
                 return CastResult(iota, continuation, newImage, listOf(), ResolvedPatternType.ESCAPED, HexEvalSounds.NORMAL_EXECUTE)
             }
 
-            if (this.image.parenCount > 0) {
+            val result = if (this.image.parenCount > 0) {
                 // Handle parens escaping
-                return iota.executeInParens(this, world, continuation)
+                iota.executeInParens(this, world, continuation)
             } else {
                 // Handle normal execution behavior
-                return iota.execute(this, world, continuation)
+                iota.execute(this, world, continuation)
             }
+
+            // if simulating, push a bool for whether the cast would have succeeded; do not perform any side effects
+            if (this.image.simulateNext) {
+                val tooBig = result.newData != null && IotaType.isTooLargeToSerialize(result.newData.stack)
+                val newStack = this.image.stack.toMutableList()
+                newStack.add(BooleanIota(result.resolutionType.success && !tooBig))
+                val newImage = this.image.copy(
+                    stack = newStack,
+                    simulateNext = false
+                )
+                return CastResult(iota, continuation, newImage, listOf(), ResolvedPatternType.SIMULATED, HexEvalSounds.NORMAL_EXECUTE)
+            }
+
+            // otherwise, return the original CastResult to perform all the side effects, stack manip, etc
+            return result
         } catch (exception: Exception) {
             // This means something very bad has happened
             exception.printStackTrace()

Common/src/main/java/at/petrak/hexcasting/api/utils/HexUtils.kt

@@ -9,13 +9,15 @@ import at.petrak.hexcasting.api.casting.iota.NullIota
 import at.petrak.hexcasting.api.casting.math.HexCoord
 import at.petrak.hexcasting.api.casting.validateSubIotas
 import at.petrak.hexcasting.api.mod.HexTags
+import com.mojang.datafixers.util.Function6
 import net.minecraft.ChatFormatting
 import net.minecraft.core.HolderLookup
 import net.minecraft.core.Registry
 import net.minecraft.nbt.*
 import net.minecraft.network.chat.Component
 import net.minecraft.network.chat.MutableComponent
 import net.minecraft.network.chat.Style
+import net.minecraft.network.codec.StreamCodec
 import net.minecraft.resources.ResourceKey
 import net.minecraft.resources.ResourceLocation
 import net.minecraft.server.level.ServerLevel
@@ -28,6 +30,7 @@ import net.minecraft.world.phys.Vec2
 import net.minecraft.world.phys.Vec3
 import java.lang.ref.WeakReference
 import java.util.*
+import java.util.function.Function
 import kotlin.math.absoluteValue
 import kotlin.math.max
 import kotlin.math.min
@@ -330,3 +333,38 @@ fun <T : Iota> validateIotaList(iotaList: List<T>, serverLevel: ServerLevel): Li
     return iotaList.map { validateIota(it, serverLevel) }
 }
 
+
+// vanilla's StreamCodec.composite() only supports up to six fields in 1.21
+fun <B, C, T1, T2, T3, T4, T5, T6, T7> compositeCodecSeven(
+    streamCodec1: StreamCodec<in B, T1>, function1: Function<C, T1>,
+    streamCodec2: StreamCodec<in B, T2>, function2: Function<C, T2>,
+    streamCodec3: StreamCodec<in B, T3>, function3: Function<C, T3>,
+    streamCodec4: StreamCodec<in B, T4>, function4: Function<C, T4>,
+    streamCodec5: StreamCodec<in B, T5>, function5: Function<C, T5>,
+    streamCodec6: StreamCodec<in B, T6>, function6: Function<C, T6>,
+    streamCodec7: StreamCodec<in B, T7>, function7: Function<C, T7>,
+    createFunction: Function7<T1, T2, T3, T4, T5, T6, T7, C>
+): StreamCodec<B, C> {
+    return object : StreamCodec<B, C> {
+        override fun decode(stream: B): C {
+            val field1 = streamCodec1.decode(stream)
+            val field2 = streamCodec2.decode(stream)
+            val field3 = streamCodec3.decode(stream)
+            val field4 = streamCodec4.decode(stream)
+            val field5 = streamCodec5.decode(stream)
+            val field6 = streamCodec6.decode(stream)
+            val field7 = streamCodec7.decode(stream)
+            return createFunction.invoke(field1, field2, field3, field4, field5, field6, field7)
+        }
+
+        override fun encode(stream: B, obj: C) {
+            streamCodec1.encode(stream, function1.apply(obj))
+            streamCodec2.encode(stream, function2.apply(obj))
+            streamCodec3.encode(stream, function3.apply(obj))
+            streamCodec4.encode(stream, function4.apply(obj))
+            streamCodec5.encode(stream, function5.apply(obj))
+            streamCodec6.encode(stream, function6.apply(obj))
+            streamCodec7.encode(stream, function7.apply(obj))
+        }
+    }
+}

Common/src/main/java/at/petrak/hexcasting/common/blocks/circles/directrix/BlockBooleanDirectrix.java

@@ -62,7 +62,7 @@ public ControlFlow acceptControlFlow(CastingImage imageIn, CircleCastEnv env, Di
             ? bs.getValue(FACING).getOpposite()
             : bs.getValue(FACING);
         var imageOut = imageIn.copy(stack, imageIn.getParenCount(), imageIn.getParenthesized(),
-            imageIn.getEscapeNext(), imageIn.getOpsConsumed(), imageIn.getUserData());
+            imageIn.getEscapeNext(), imageIn.getSimulateNext(), imageIn.getOpsConsumed(), imageIn.getUserData());
 
         return new ControlFlow.Continue(imageOut, List.of(this.exitPositionFromDirection(pos, outputDir)));
     }

Common/src/main/java/at/petrak/hexcasting/common/casting/actions/escaping/OpSimulate.kt

@@ -0,0 +1,17 @@
+package at.petrak.hexcasting.common.casting.actions.escaping
+
+import at.petrak.hexcasting.api.casting.castables.Action
+import at.petrak.hexcasting.api.casting.eval.CastingEnvironment
+import at.petrak.hexcasting.api.casting.eval.OperationResult
+import at.petrak.hexcasting.api.casting.eval.vm.CastingImage
+import at.petrak.hexcasting.api.casting.eval.vm.SpellContinuation
+import at.petrak.hexcasting.common.lib.hex.HexEvalSounds
+
+object OpSimulate : Action {
+    override fun operate(env: CastingEnvironment, image: CastingImage, continuation: SpellContinuation): OperationResult {
+        val image2 = image.copy(
+            simulateNext = true
+        )
+        return OperationResult(image2, listOf(), continuation, HexEvalSounds.NORMAL_EXECUTE)
+    }
+}