Merge branch 'main' into 1.19

Author: object-Object

CHANGELOG.md

@@ -4,6 +4,19 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and [Pydantic's HISTORY.md](https://github.com/pydantic/pydantic/blob/main/HISTORY.md), and this project *mostly* adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [UNRELEASED]
+
+### Changed
+
+- A message is now displayed if attempting to use an Evaluator when not debugging, instead of silently failing.
+- Evaluators are now prevented from evaluating patterns after an Uncaught Mishap breakpoint is hit.
+
+### Fixed
+
+- Evaluators were unable to cast any spells requiring media.
+- When debugging, spells requiring media would fail if a Debugger was not in the hand that the debug session was started with.
+- Evaluator mishaps were unintentionally caught by the Uncaught Mishaps option, and did not apply side effects to the stack.
+
 ## 0.2.0+1.19.2
 
 ### Added

Common/src/main/kotlin/gay/object/hexdebug/adapter/DebugAdapter.kt

@@ -1,6 +1,7 @@
 package gay.`object`.hexdebug.adapter
 
 import at.petrak.hexcasting.api.spell.SpellList
+import at.petrak.hexcasting.api.spell.casting.CastingContext
 import at.petrak.hexcasting.api.spell.casting.ControllerInfo
 import at.petrak.hexcasting.api.spell.casting.ResolvedPatternType
 import at.petrak.hexcasting.api.spell.iota.Iota
@@ -107,22 +108,21 @@ open class DebugAdapter(val player: ServerPlayer) : IDebugProtocolServer {
         })
     }
 
-    fun evaluate(pattern: HexPattern) = evaluate(PatternIota(pattern))
+    fun evaluate(env: CastingEnvironment, pattern: HexPattern) = evaluate(env, PatternIota(pattern))
 
-    fun evaluate(iota: Iota) = evaluate(SpellList.LList(listOf(iota)))
+    fun evaluate(env: CastingEnvironment, iota: Iota) = evaluate(env, SpellList.LList(listOf(iota)))
 
-    fun evaluate(list: SpellList) = debugger?.let {
-        val result = it.evaluate(list)
-        if (result?.startedEvaluating == true) {
+    fun evaluate(env: CastingEnvironment, list: SpellList) = debugger?.let {
+        val result = it.evaluate(env, list)
+        if (result.startedEvaluating) {
             setEvaluatorState(ItemEvaluator.EvalState.MODIFIED)
         }
         handleDebuggerStep(result)
     }
 
     fun resetEvaluator() {
         setEvaluatorState(ItemEvaluator.EvalState.DEFAULT)
-        debugger?.also {
-            it.resetEvaluator()
+        if (debugger?.resetEvaluator() == true) {
             sendStoppedEvent("step")
         }
     }
@@ -141,12 +141,12 @@ open class DebugAdapter(val player: ServerPlayer) : IDebugProtocolServer {
             ?: ResponseError(ResponseErrorCode.InternalError, e.toString(), e.stackTraceToString())
     }
 
-    private fun handleDebuggerStep(result: DebugStepResult?): ControllerInfo? {
-        val view = debugger?.getClientView()?.also {
+    private fun handleDebuggerStep(result: DebugStepResult): ControllerInfo? {
+        val view = result.clientInfo?.also {
             IXplatAbstractions.INSTANCE.sendPacketToPlayer(player, MsgNewSpellPatternAck(it, -1))
         }
 
-        if (result == null) {
+        if (result.isDone) {
             terminate(null)
             return view
         }
@@ -158,7 +158,7 @@ open class DebugAdapter(val player: ServerPlayer) : IDebugProtocolServer {
             })
         }
 
-        sendStoppedEvent(result.reason)
+        sendStoppedEvent(result.reason.value)
         return view
     }
 
@@ -233,29 +233,29 @@ open class DebugAdapter(val player: ServerPlayer) : IDebugProtocolServer {
 
     override fun configurationDone(args: ConfigurationDoneArguments?): CompletableFuture<Void> {
         knownPlayers.add(player.uuid)
-        handleDebuggerStep(debugger?.start())
+        debugger?.start()?.also(::handleDebuggerStep)
         return futureOf()
     }
 
     // stepping
 
     override fun next(args: NextArguments?): CompletableFuture<Void> {
-        handleDebuggerStep(debugger?.executeUntilStopped(RequestStepType.OVER))
+        debugger?.executeUntilStopped(RequestStepType.OVER)?.also(::handleDebuggerStep)
         return futureOf()
     }
 
     override fun continue_(args: ContinueArguments?): CompletableFuture<ContinueResponse> {
-        handleDebuggerStep(debugger?.executeUntilStopped())
+        debugger?.executeUntilStopped()?.also(::handleDebuggerStep)
         return futureOf()
     }
 
     override fun stepIn(args: StepInArguments?): CompletableFuture<Void> {
-        handleDebuggerStep(debugger?.executeOnce())
+        debugger?.executeOnce()?.also(::handleDebuggerStep)
         return futureOf()
     }
 
     override fun stepOut(args: StepOutArguments?): CompletableFuture<Void> {
-        handleDebuggerStep(debugger?.executeUntilStopped(RequestStepType.OUT))
+        debugger?.executeUntilStopped(RequestStepType.OUT)?.also(::handleDebuggerStep)
         return futureOf()
     }
 

Common/src/main/kotlin/gay/object/hexdebug/casting/eval/DebuggerCastEnv.kt

@@ -0,0 +1,56 @@
+package gay.`object`.hexdebug.casting.eval
+
+import at.petrak.hexcasting.api.casting.castables.Action
+import at.petrak.hexcasting.api.casting.eval.env.PackagedItemCastEnv
+import at.petrak.hexcasting.api.casting.eval.sideeffects.OperatorSideEffect
+import gay.`object`.hexdebug.debugger.DebugStepType
+import gay.`object`.hexdebug.utils.findMediaHolderInHand
+import gay.`object`.hexdebug.utils.otherHand
+import net.minecraft.network.chat.Component
+import net.minecraft.server.level.ServerPlayer
+import net.minecraft.world.InteractionHand
+
+class DebuggerCastEnv(
+    caster: ServerPlayer,
+    castingHand: InteractionHand,
+) : PackagedItemCastEnv(caster, castingHand), IDebugCastEnv {
+    private val item = caster.getItemInHand(castingHand).item
+
+    override var lastEvaluatedAction: Action? = null
+    override var lastDebugStepType: DebugStepType? = null
+
+    override fun printMessage(message: Component) {
+        super.printMessage(message)
+        printDebugMessage(caster, message)
+    }
+
+    override fun sendMishapMsgToPlayer(mishap: OperatorSideEffect.DoMishap) {
+        super.sendMishapMsgToPlayer(mishap)
+        printDebugMishap(this, caster, mishap)
+    }
+
+    override fun extractMediaEnvironment(cost: Long): Long {
+        if (caster.isCreative) return 0
+
+        var costLeft = cost
+
+        // allow extracting from a debugger item in either hand, preferring the one we started casting with
+        // NOTE: if holding two debuggers and the first is empty, this will take the empty one, not the other one
+        val casterMediaHolder = caster.findMediaHolderInHand(castingHand, item)
+            ?: caster.findMediaHolderInHand(castingHand.otherHand, item)
+
+        // The contracts on the AD and on this function are different.
+        // ADs return the amount extracted, this wants the amount left
+        if (casterMediaHolder != null) {
+            val extracted = casterMediaHolder.withdrawMedia(costLeft.toInt().toLong(), false)
+            costLeft -= extracted
+        }
+
+        // debugger can always extract from inventory
+        if (costLeft > 0) {
+            costLeft = extractMediaFromInventory(costLeft, canOvercast())
+        }
+
+        return costLeft
+    }
+}

Common/src/main/kotlin/gay/object/hexdebug/casting/eval/IMixinCastingContext.kt

@@ -27,3 +27,15 @@ fun printDebugMessage(
 ) {
     DebugAdapterManager[caster]?.print(message.string + "\n", category, withSource)
 }
+
+fun printDebugMishap(
+    env: CastingContext,
+    caster: ServerPlayer,
+    mishap: OperatorSideEffect.DoMishap,
+) {
+    mishap.mishap.errorMessageWithName(env, mishap.errorCtx)?.also {
+        printDebugMessage(caster, it, OutputEventArgumentsCategory.STDERR)
+    }
+}
+
+val CastingVM.debugCastEnv get() = ctx as IMixinCastingContext

Common/src/main/kotlin/gay/object/hexdebug/debugger/DebugStepResult.kt

@@ -1,14 +1,20 @@
 package gay.`object`.hexdebug.debugger
 
+import at.petrak.hexcasting.api.casting.eval.ExecutionClientView
 import org.eclipse.lsp4j.debug.Source
 import org.eclipse.lsp4j.debug.LoadedSourceEventArgumentsReason as LoadedSourceReason
 
 data class DebugStepResult(
-    val reason: String,
+    val reason: StopReason,
     val type: DebugStepType? = null,
+    val clientInfo: ExecutionClientView? = null,
     val loadedSources: Map<Source, LoadedSourceReason> = mapOf(),
     val startedEvaluating: Boolean = false,
 ) {
+    val isDone = reason == StopReason.TERMINATED
+
+    fun done() = copy(reason = StopReason.TERMINATED)
+
     operator fun plus(other: DebugStepResult) = copy(
         loadedSources = loadedSources + other.loadedSources,
     )

Common/src/main/kotlin/gay/object/hexdebug/debugger/Enums.kt

@@ -1,38 +1,26 @@
 package gay.`object`.hexdebug.debugger
 
+enum class StopReason(val value: String, val stopImmediately: Boolean) {
+    STEP("step", false),
+    BREAKPOINT("breakpoint", true),
+    EXCEPTION("exception", true),
+    STARTED("entry", true),
+    TERMINATED("terminated", true),
+}
+
 enum class DebugStepType {
     IN,
     OUT,
     JUMP,
     ESCAPE,
 }
 
-enum class SourceBreakpointMode {
-    EVALUATED,
-    ESCAPED,
-    ALL;
-
-    val label get() = when (this) {
-        EVALUATED -> "Evaluated"
-        ESCAPED -> "Escaped"
-        ALL -> "All"
-    }
-
-    val description get() = when (this) {
-        EVALUATED -> "Stop if this iota would be evaluated. (default)"
-        ESCAPED -> "Stop if this iota would be escaped."
-        ALL -> "Always stop at this iota."
-    }
+enum class SourceBreakpointMode(val label: String, val description: String) {
+    EVALUATED("Evaluated", "Stop if this iota would be evaluated. (default)"),
+    ESCAPED("Escaped", "Stop if this iota would be escaped."),
+    ALL("All", "Always stop at this iota."),
 }
 
-enum class ExceptionBreakpointType {
-    UNCAUGHT_MISHAPS;
-
-    val label get() = when (this) {
-        UNCAUGHT_MISHAPS -> "Uncaught Mishaps"
-    }
-
-    val isDefault get() = when (this) {
-        UNCAUGHT_MISHAPS -> true
-    }
+enum class ExceptionBreakpointType(val label: String, val isDefault: Boolean) {
+    UNCAUGHT_MISHAPS("Uncaught Mishaps", true),
 }