DEBUGGER

Common/build.gradle

@@ -23,6 +23,9 @@ dependencies {
     modCompileOnly libs.paucal.common
     modCompileOnly libs.hexcasting.fabric
     modCompileOnly libs.patchouli.xplat
+
+    modApi libs.lsp4j
+    modApi libs.lsp4j.debug
 }
 
 publishing {

Common/src/main/java/ca/objectobject/hexdebug/HexDebugAbstractions.java

@@ -3,8 +3,6 @@
 import dev.architectury.injectables.annotations.ExpectPlatform;
 import dev.architectury.platform.Platform;
 
-import java.nio.file.Path;
-
 public class HexDebugAbstractions {
     /**
      * This explanation is mostly from Architectury's template project.
@@ -18,22 +16,17 @@ public class HexDebugAbstractions {
      * <p>
      * Example:
      * <p>
-     * Expect: ca.objectobject.hexdebug.HexDebugAbstractions#getConfigDirectory()
+     * Expect: ca.objectobject.hexdebug.HexDebugAbstractions#get()
      * <p>
-     * Actual Fabric: ca.objectobject.hexdebug.fabric.HexDebugAbstractionsImpl#getConfigDirectory()
+     * Actual Fabric: ca.objectobject.hexdebug.fabric.HexDebugAbstractionsImpl#get()
      * <p>
-     * Actual Forge: ca.objectobject.hexdebug.forge.HexDebugAbstractionsImpl#getConfigDirectory()
+     * Actual Forge: ca.objectobject.hexdebug.forge.HexDebugAbstractionsImpl#get()
      * <p>
      * <a href="https://plugins.jetbrains.com/plugin/16210-architectury">You should also get the IntelliJ plugin to help with @ExpectPlatform.</a>
      */
     @ExpectPlatform
-    public static Path getConfigDirectory() {
+    public static IHexDebugAbstractions get() {
         // Just throw an error, the content should get replaced at runtime.
         throw new AssertionError();
     }
-
-    @ExpectPlatform
-    public static void initPlatformSpecific() {
-        throw new AssertionError();
-    }
 }

Common/src/main/java/ca/objectobject/hexdebug/IHexDebugAbstractions.java

@@ -0,0 +1,16 @@
+package ca.objectobject.hexdebug;
+
+import net.minecraft.server.MinecraftServer;
+
+import java.nio.file.Path;
+import java.util.function.Consumer;
+
+public interface IHexDebugAbstractions {
+    Path getConfigDirectory();
+
+    void initPlatformSpecific();
+
+    void onServerStarted(Consumer<MinecraftServer> callback);
+
+    void onServerStopping(Consumer<MinecraftServer> callback);
+}

Common/src/main/java/ca/objectobject/hexdebug/registry/HexDebugItemRegistry.java

@@ -0,0 +1,22 @@
+package ca.objectobject.hexdebug.registry;
+
+import ca.objectobject.hexdebug.HexDebug;
+import ca.objectobject.hexdebug.common.items.ItemDebugger;
+import dev.architectury.registry.registries.DeferredRegister;
+import dev.architectury.registry.registries.RegistrySupplier;
+import net.minecraft.core.registries.Registries;
+import net.minecraft.world.item.Item;
+
+public class HexDebugItemRegistry {
+    // Register items through this
+    public static final DeferredRegister<Item> ITEMS = DeferredRegister.create(HexDebug.MODID, Registries.ITEM);
+
+    public static void init() {
+        ITEMS.register();
+    }
+
+    // During the loading phase, refrain from accessing suppliers' items (e.g. EXAMPLE_ITEM.get()), they will not be available
+    public static final RegistrySupplier<Item> DUMMY_ITEM = ITEMS.register("debugger", () -> new ItemDebugger(new ItemDebugger.Properties()));
+
+
+}

Common/src/main/kotlin/ca/objectobject/hexdebug/HexDebug.kt

@@ -0,0 +1,32 @@
+package ca.objectobject.hexdebug
+
+import ca.objectobject.hexdebug.registry.HexDebugItemRegistry
+import ca.objectobject.hexdebug.server.HexDebugServerManager
+import net.minecraft.resources.ResourceLocation
+import org.apache.logging.log4j.LogManager
+import org.apache.logging.log4j.Logger
+
+object HexDebug {
+    const val MODID = "hexdebug"
+
+    @JvmField
+    val LOGGER: Logger = LogManager.getLogger(MODID)
+
+    @JvmStatic
+    fun init() {
+        LOGGER.info("HexDebug is here!")
+        HexDebugItemRegistry.init()
+        HexDebugAbstractions.get().apply {
+            initPlatformSpecific()
+            onServerStarted {
+                HexDebugServerManager.start()
+            }
+            onServerStopping {
+                HexDebugServerManager.stop()
+            }
+        }
+    }
+
+    @JvmStatic
+    fun id(path: String) = ResourceLocation(MODID, path)
+}

Common/src/main/kotlin/ca/objectobject/hexdebug/common/items/ItemDebugger.kt

@@ -0,0 +1,111 @@
+package ca.objectobject.hexdebug.common.items
+
+import at.petrak.hexcasting.api.casting.ParticleSpray
+import at.petrak.hexcasting.api.casting.eval.vm.CastingVM
+import at.petrak.hexcasting.api.casting.iota.Iota
+import at.petrak.hexcasting.api.casting.iota.ListIota
+import at.petrak.hexcasting.api.casting.iota.PatternIota
+import at.petrak.hexcasting.api.item.IotaHolderItem
+import at.petrak.hexcasting.api.mod.HexConfig
+import at.petrak.hexcasting.api.utils.getCompound
+import at.petrak.hexcasting.common.items.magic.ItemPackagedHex
+import at.petrak.hexcasting.common.msgs.MsgNewSpiralPatternsS2C
+import at.petrak.hexcasting.xplat.IXplatAbstractions
+import ca.objectobject.hexdebug.debugger.DebugCastArgs
+import ca.objectobject.hexdebug.debugger.DebugItemCastEnv
+import ca.objectobject.hexdebug.server.HexDebugServerManager
+import ca.objectobject.hexdebug.server.HexDebugServerState
+import net.minecraft.network.chat.Component
+import net.minecraft.server.level.ServerLevel
+import net.minecraft.server.level.ServerPlayer
+import net.minecraft.stats.Stat
+import net.minecraft.stats.Stats
+import net.minecraft.world.InteractionHand
+import net.minecraft.world.InteractionResultHolder
+import net.minecraft.world.entity.player.Player
+import net.minecraft.world.item.ItemStack
+import net.minecraft.world.level.Level
+import net.minecraft.world.phys.Vec3
+
+class ItemDebugger(properties: Properties) : ItemPackagedHex(properties), IotaHolderItem {
+    override fun canDrawMediaFromInventory(stack: ItemStack?) = true
+
+    override fun breakAfterDepletion() = false
+
+    override fun cooldown() = HexConfig.common().artifactCooldown()
+
+    override fun readIotaTag(stack: ItemStack?) = stack?.getCompound(TAG_PROGRAM)
+
+    override fun canWrite(stack: ItemStack?, iota: Iota?) = iota is ListIota
+
+    override fun writeDatum(stack: ItemStack?, iota: Iota?) = writeHex(stack, (iota as ListIota).list.toList(), null, 0)
+
+    override fun use(world: Level, player: Player, usedHand: InteractionHand): InteractionResultHolder<ItemStack> {
+        val stack = player.getItemInHand(usedHand)
+
+        if (world.isClientSide) {
+            return InteractionResultHolder.success(stack)
+        }
+
+        val serverPlayer = player as ServerPlayer
+        val serverLevel = world as ServerLevel
+
+        val instrs = if (hasHex(stack)) {
+            getHex(stack, serverLevel) ?: return InteractionResultHolder.fail(stack)
+        } else {
+            val datumHolder = IXplatAbstractions.INSTANCE.findDataHolder(player.getItemInHand(usedHand.otherHand))
+            when (val iota = datumHolder?.readIota(serverLevel)) {
+                is ListIota -> iota.list.toList()
+                else -> null
+            }
+        } ?: return InteractionResultHolder.fail(stack)
+
+        val ctx = DebugItemCastEnv(serverPlayer, usedHand)
+        val vm = CastingVM.empty(ctx)
+        val castArgs = DebugCastArgs(vm, instrs, serverLevel) {
+            if (it is PatternIota) {
+                val packet = MsgNewSpiralPatternsS2C(serverPlayer.uuid, listOf(it.pattern), 140)
+                IXplatAbstractions.INSTANCE.sendPacketToPlayer(serverPlayer, packet)
+                IXplatAbstractions.INSTANCE.sendPacketTracking(serverPlayer, packet)
+            }
+        }
+
+        val debugServer = HexDebugServerManager.server
+        if (debugServer == null) {
+            HexDebugServerManager.queuedCast = castArgs
+            player.sendSystemMessage(Component.translatable("text.hexdebug.no_client"), false)
+        } else when (debugServer.state) {
+            HexDebugServerState.NOT_READY, HexDebugServerState.READY -> if (!debugServer.startDebugging(castArgs)) {
+                return InteractionResultHolder.fail(stack)
+            }
+            HexDebugServerState.DEBUGGING -> debugServer.next(null)
+            else -> return InteractionResultHolder.fail(stack)
+        }
+
+        ParticleSpray(player.position(), Vec3(0.0, 1.5, 0.0), 0.4, Math.PI / 3, 30)
+            .sprayParticles(serverPlayer.serverLevel(), ctx.pigment)
+
+        val broken = breakAfterDepletion() && getMedia(stack) == 0L
+        val stat: Stat<*> = if (broken) {
+            Stats.ITEM_BROKEN[this]
+        } else {
+            Stats.ITEM_USED[this]
+        }
+        player.awardStat(stat)
+
+        serverPlayer.cooldowns.addCooldown(this, this.cooldown())
+
+        if (broken) {
+            stack.shrink(1)
+            player.broadcastBreakEvent(usedHand)
+            return InteractionResultHolder.consume(stack)
+        } else {
+            return InteractionResultHolder.success(stack)
+        }
+    }
+}
+
+val InteractionHand.otherHand get() = when (this) {
+    InteractionHand.MAIN_HAND -> InteractionHand.OFF_HAND
+    InteractionHand.OFF_HAND -> InteractionHand.MAIN_HAND
+}

Common/src/main/kotlin/ca/objectobject/hexdebug/debugger/DebugCastArgs.kt

@@ -0,0 +1,12 @@
+package ca.objectobject.hexdebug.debugger
+
+import at.petrak.hexcasting.api.casting.eval.vm.CastingVM
+import at.petrak.hexcasting.api.casting.iota.Iota
+import net.minecraft.server.level.ServerLevel
+
+data class DebugCastArgs(
+    val vm: CastingVM,
+    val iotas: List<Iota>,
+    val world: ServerLevel,
+    val onExecute: ((Iota) -> Unit)? = null
+)

Common/src/main/kotlin/ca/objectobject/hexdebug/debugger/DebugCastEnv.kt

@@ -0,0 +1,14 @@
+package ca.objectobject.hexdebug.debugger
+
+import at.petrak.hexcasting.api.casting.eval.env.PackagedItemCastEnv
+import ca.objectobject.hexdebug.server.HexDebugServerManager
+import net.minecraft.network.chat.Component
+import net.minecraft.server.level.ServerPlayer
+import net.minecraft.world.InteractionHand
+
+class DebugItemCastEnv(caster: ServerPlayer, castingHand: InteractionHand) : PackagedItemCastEnv(caster, castingHand) {
+    override fun printMessage(message: Component) {
+        super.printMessage(message)
+        HexDebugServerManager.server?.print(message.string + "\n")
+    }
+}