Add more commands and rework dsl

4 files changed, 320 insertions, 8 deletions

diff --git a/src/main/kotlin/io/github/moulberry/notenoughupdates/commands/dev/DiagCommand.kt b/src/main/kotlin/io/github/moulberry/notenoughupdates/commands/dev/DiagCommand.kt
new file mode 100644
index 00000000..67765b9d
--- /dev/null
+++ b/src/main/kotlin/io/github/moulberry/notenoughupdates/commands/dev/DiagCommand.kt
@@ -0,0 +1,78 @@
+/*
+ * Copyright (C) 2023 NotEnoughUpdates contributors
+ *
+ * This file is part of NotEnoughUpdates.
+ *
+ * NotEnoughUpdates is free software: you can redistribute it
+ * and/or modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation, either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * NotEnoughUpdates is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with NotEnoughUpdates. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package io.github.moulberry.notenoughupdates.commands.dev
+
+import com.mojang.brigadier.arguments.BoolArgumentType.bool
+import io.github.moulberry.notenoughupdates.NotEnoughUpdates
+import io.github.moulberry.notenoughupdates.autosubscribe.NEUAutoSubscribe
+import io.github.moulberry.notenoughupdates.events.RegisterBrigadierCommandEvent
+import io.github.moulberry.notenoughupdates.miscfeatures.CrystalMetalDetectorSolver
+import io.github.moulberry.notenoughupdates.miscfeatures.CrystalWishingCompassSolver
+import io.github.moulberry.notenoughupdates.options.customtypes.NEUDebugFlag
+import io.github.moulberry.notenoughupdates.util.brigadier.*
+import io.github.moulberry.notenoughupdates.util.brigadier.EnumArgumentType.Companion.enum
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent
+
+// Why is this not merged into /neudevtest
+@NEUAutoSubscribe
+class DiagCommand {
+    @SubscribeEvent
+    fun onCommands(event: RegisterBrigadierCommandEvent) {
+        event.command("neudiag") {
+            thenLiteral("metal") {
+                thenExecute {
+                    CrystalMetalDetectorSolver.logDiagnosticData(true)
+                    reply("Enabled metal detector diagnostic logging.")
+                }
+                thenLiteral("center") {
+                    thenArgumentExecute("usecenter", bool()) { useCenter ->
+                        CrystalMetalDetectorSolver.setDebugDoNotUseCenter(this[useCenter])
+                        reply("Center coordinates-based solutions ${if (this[useCenter]) "enabled" else "disabled"}")
+                    }
+                }
+            }
+            thenLiteralExecute("wishing") {
+                CrystalWishingCompassSolver.getInstance().logDiagnosticData(true)
+                reply("Enabled wishing compass diagnostic logging")
+            }
+            thenLiteral("debug") {
+                thenExecute {
+                    reply("Effective debug flags: \n${NEUDebugFlag.getEnabledFlags()}")
+                }
+                thenLiteralExecute("list") {
+                    reply("Here are all flags:\n${NEUDebugFlag.getFlagList()}")
+                }
+                thenLiteral("setflag") {
+                    thenArgument("flag", enum<NEUDebugFlag>()) { flag ->
+                        thenArgumentExecute("enable", bool()) { enable ->
+                            val debugFlags = NotEnoughUpdates.INSTANCE.config.hidden.debugFlags
+                            if (this[enable]) {
+                                debugFlags.add(this[flag])
+                            } else {
+                                debugFlags.remove(this[flag])
+                            }
+                            reply("${if(this[enable]) "Enabled" else "Disabled"} the flag ${this[flag]}.")
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/src/main/kotlin/io/github/moulberry/notenoughupdates/commands/dev/PackDevCommand.kt b/src/main/kotlin/io/github/moulberry/notenoughupdates/commands/dev/PackDevCommand.kt
new file mode 100644
index 00000000..6c1fa371
--- /dev/null
+++ b/src/main/kotlin/io/github/moulberry/notenoughupdates/commands/dev/PackDevCommand.kt
@@ -0,0 +1,163 @@
+/*
+ * Copyright (C) 2023 NotEnoughUpdates contributors
+ *
+ * This file is part of NotEnoughUpdates.
+ *
+ * NotEnoughUpdates is free software: you can redistribute it
+ * and/or modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation, either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * NotEnoughUpdates is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with NotEnoughUpdates. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package io.github.moulberry.notenoughupdates.commands.dev
+
+import com.mojang.brigadier.arguments.DoubleArgumentType.doubleArg
+import com.mojang.brigadier.builder.ArgumentBuilder
+import io.github.moulberry.notenoughupdates.NotEnoughUpdates
+import io.github.moulberry.notenoughupdates.autosubscribe.NEUAutoSubscribe
+import io.github.moulberry.notenoughupdates.core.util.MiscUtils
+import io.github.moulberry.notenoughupdates.events.RegisterBrigadierCommandEvent
+import io.github.moulberry.notenoughupdates.util.brigadier.*
+import net.minecraft.client.Minecraft
+import net.minecraft.client.entity.AbstractClientPlayer
+import net.minecraft.command.ICommandSender
+import net.minecraft.entity.Entity
+import net.minecraft.entity.EntityLiving
+import net.minecraft.entity.EntityLivingBase
+import net.minecraft.entity.item.EntityArmorStand
+import net.minecraft.entity.player.EntityPlayer
+import net.minecraft.item.ItemStack
+import net.minecraft.util.EnumChatFormatting
+
+@NEUAutoSubscribe
+class PackDevCommand {
+
+    fun <T : EntityLivingBase, U : ArgumentBuilder<ICommandSender, U>> U.npcListCommand(
+        name: String,
+        singleCommand: String,
+        multipleCommand: String,
+        clazz: Class<T>,
+        provider: () -> List<Entity>
+    ) {
+        fun getEntities(distance: Double): List<T> {
+            val distanceSquared = distance * distance
+            val thePlayer = Minecraft.getMinecraft().thePlayer
+            return provider()
+                .asSequence()
+                .filterIsInstance(clazz)
+                .filter { it != thePlayer }
+                .filter { it.getDistanceSqToEntity(thePlayer) < distanceSquared }
+                .toList()
+        }
+
+        thenLiteral(singleCommand) {
+            thenArgumentExecute("distance", doubleArg(0.0)) { dist ->
+                val dist = this[dist]
+                val entity = getEntities(dist).firstOrNull()
+                if (entity == null) {
+                    reply("No $name found within $dist blocks")
+                    return@thenArgumentExecute
+                }
+                MiscUtils.copyToClipboard(StringBuilder().appendEntityData(entity).toString().trim())
+                reply("Copied data to clipboard")
+            }
+        }
+        thenLiteral(multipleCommand) {
+            thenArgumentExecute("distance", doubleArg(0.0)) { dist ->
+                val dist = this[dist]
+                val entity = getEntities(dist)
+                val sb = StringBuilder()
+                reply("Found ${entity.size} ${name}s")
+                if (entity.isNotEmpty()) {
+                    entity.forEach {
+                        sb.appendEntityData(it)
+                    }
+                    MiscUtils.copyToClipboard(sb.toString().trim())
+
+                    reply("Copied data to clipboard")
+                }
+            }
+        }
+    }
+
+    fun StringBuilder.appendEntityData(entity: EntityLivingBase) {
+        if (entity is EntityPlayer) {
+            append("Player UUID: ")
+            appendLine(entity.uniqueID)
+            if (entity is AbstractClientPlayer) {
+                append("Entity Texture Id: ")
+                appendLine(entity.locationSkin.resourcePath?.replace("skins/", ""))
+            }
+        }
+        append("Custom Name Tag: ")
+        appendLine(entity.customNameTag ?: "null")
+        append("Mob: ")
+        appendLine(entity.name)
+        append("Entity Id: ")
+        appendLine(entity.entityId)
+
+        appendItemData("Item", entity.heldItem)
+
+        for ((slot, name) in listOf("Boots", "Leggings", "Chestplate", "Helmet").withIndex()) {
+            val armorPiece = entity.getCurrentArmor(slot)
+            appendItemData(name, armorPiece)
+        }
+        appendLine()
+        appendLine()
+    }
+
+    fun StringBuilder.appendItemData(name: String, item: ItemStack?) {
+        append("$name: ")
+        if (item != null) {
+            appendLine(item)
+            append("$name Display Name")
+            appendLine(item.displayName)
+            append("$name Tag Compound: ")
+            val compound = item.tagCompound
+            if (compound == null) {
+                appendLine("null")
+            } else {
+                appendLine(compound)
+                append("$name Tag Compound Extra Attributes")
+                appendLine(compound.getTag("ExtraAttributes"))
+            }
+        } else {
+            appendLine("null")
+        }
+
+    }
+
+
+    fun onCommands(event: RegisterBrigadierCommandEvent) {
+        event.command("neupackdev") {
+            thenExecute {
+                NotEnoughUpdates.INSTANCE.packDevEnabled = !NotEnoughUpdates.INSTANCE.packDevEnabled
+                if (NotEnoughUpdates.INSTANCE.packDevEnabled) {
+                    reply("${EnumChatFormatting.GREEN}Enabled pack developer mode.")
+                } else {
+                    reply("${EnumChatFormatting.RED}Disabled pack developer mode.")
+                }
+            }
+            npcListCommand("Player", "getplayer", "getplayers", AbstractClientPlayer::class.java) {
+                Minecraft.getMinecraft().theWorld.playerEntities
+            }
+            npcListCommand("NPC", "getnpc", "getnpcs", AbstractClientPlayer::class.java) {
+                Minecraft.getMinecraft().theWorld.playerEntities.filter { it.uniqueID?.version() != 4 }
+            }
+            npcListCommand("mob", "getmob", "getmobs", EntityLiving::class.java) {
+                Minecraft.getMinecraft().theWorld.loadedEntityList
+            }
+            npcListCommand("armor stand", "getarmorstand", "getarmorstands", EntityArmorStand::class.java) {
+                Minecraft.getMinecraft().theWorld.loadedEntityList
+            }
+        }
+    }
+}
diff --git a/src/main/kotlin/io/github/moulberry/notenoughupdates/commands/misc/FairySoulsCommand.kt b/src/main/kotlin/io/github/moulberry/notenoughupdates/commands/misc/FairySoulsCommand.kt
new file mode 100644
index 00000000..9edb36f1
--- /dev/null
+++ b/src/main/kotlin/io/github/moulberry/notenoughupdates/commands/misc/FairySoulsCommand.kt
@@ -0,0 +1,65 @@
+/*
+ * Copyright (C) 2023 NotEnoughUpdates contributors
+ *
+ * This file is part of NotEnoughUpdates.
+ *
+ * NotEnoughUpdates is free software: you can redistribute it
+ * and/or modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation, either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * NotEnoughUpdates is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with NotEnoughUpdates. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package io.github.moulberry.notenoughupdates.commands.misc
+
+import io.github.moulberry.notenoughupdates.autosubscribe.NEUAutoSubscribe
+import io.github.moulberry.notenoughupdates.events.RegisterBrigadierCommandEvent
+import io.github.moulberry.notenoughupdates.miscfeatures.FairySouls
+import io.github.moulberry.notenoughupdates.util.brigadier.literal
+import io.github.moulberry.notenoughupdates.util.brigadier.reply
+import io.github.moulberry.notenoughupdates.util.brigadier.thenLiteral
+import io.github.moulberry.notenoughupdates.util.brigadier.thenLiteralExecute
+import net.minecraft.util.EnumChatFormatting.DARK_PURPLE
+import net.minecraft.util.EnumChatFormatting.RED
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent
+
+@NEUAutoSubscribe
+class FairySoulsCommand {
+
+    @SubscribeEvent
+    fun onCommands(event: RegisterBrigadierCommandEvent) {
+        event.command("neusouls", "fairysouls") {
+            val enable = thenLiteralExecute("enable") {
+                if (!FairySouls.getInstance().isTrackSouls) {
+                    reply("${RED}Fairy soul tracking is off, enable it using /neu before using this command")
+                    return@thenLiteralExecute
+                }
+                reply("${DARK_PURPLE}Enabled fairy soul waypoints")
+                FairySouls.getInstance().setShowFairySouls(true)
+            }
+            thenLiteral("on") { redirect(enable) }
+            val disable = thenLiteralExecute("disable") {
+                FairySouls.getInstance().setShowFairySouls(false)
+                reply("${DARK_PURPLE}Disabled fairy soul waypoints")
+            }
+            thenLiteral("off") { redirect(disable) }
+            val clear = thenLiteralExecute("clear") {
+                FairySouls.getInstance().markAllAsFound()
+                // Reply handled by mark all as found
+            }
+            thenLiteral("markfound") { redirect(clear) }
+            val unclear = thenLiteralExecute("unclear") {
+                FairySouls.getInstance().markAllAsMissing()
+                // Reply handled by mark all as missing
+            }
+            thenLiteral("marknotfound") { redirect(unclear) }
+        }
+    }
+}
diff --git a/src/main/kotlin/io/github/moulberry/notenoughupdates/util/brigadier/dsl.kt b/src/main/kotlin/io/github/moulberry/notenoughupdates/util/brigadier/dsl.kt
index 5c802c64..96efd1aa 100644
--- a/src/main/kotlin/io/github/moulberry/notenoughupdates/util/brigadier/dsl.kt
+++ b/src/main/kotlin/io/github/moulberry/notenoughupdates/util/brigadier/dsl.kt
@@ -24,6 +24,9 @@ import com.mojang.brigadier.builder.ArgumentBuilder
 import com.mojang.brigadier.builder.LiteralArgumentBuilder
 import com.mojang.brigadier.builder.RequiredArgumentBuilder
 import com.mojang.brigadier.context.CommandContext
+import com.mojang.brigadier.tree.ArgumentCommandNode
+import com.mojang.brigadier.tree.CommandNode
+import com.mojang.brigadier.tree.LiteralCommandNode
 import io.github.moulberry.notenoughupdates.util.iterate
 import net.minecraft.command.ICommandSender
 import net.minecraft.util.ChatComponentText
@@ -103,13 +106,13 @@ fun <T : ArgumentBuilder<DefaultSource, T>, AT : Any> T.thenArgument(
     name: String,
     argument: ArgumentType<AT>,
     block: RequiredArgumentBuilder<DefaultSource, AT>.(TypeSafeArg<AT>) -> Unit
-): T = then(argument(name, argument, block))
+): ArgumentCommandNode<DefaultSource, AT> = argument(name, argument, block).build().also(::then)
 
 fun <T : ArgumentBuilder<DefaultSource, T>, AT : Any> T.thenArgumentExecute(
     name: String,
     argument: ArgumentType<AT>,
     block: CommandContext<DefaultSource>.(TypeSafeArg<AT>) -> Unit
-): T = thenArgument(name, argument) {
+): ArgumentCommandNode<DefaultSource, AT> = thenArgument(name, argument) {
     thenExecute {
         block(it)
     }
@@ -117,27 +120,30 @@ fun <T : ArgumentBuilder<DefaultSource, T>, AT : Any> T.thenArgumentExecute(
 
 fun literal(
     name: String,
-    block: LiteralArgumentBuilder<DefaultSource>.() -> Unit
+    block: LiteralArgumentBuilder<DefaultSource>.() -> Unit = {}
 ): LiteralArgumentBuilder<DefaultSource> =
     LiteralArgumentBuilder.literal<DefaultSource>(name).also(block)
 
 fun <T : ArgumentBuilder<DefaultSource, T>> T.thenLiteral(
     name: String,
     block: LiteralArgumentBuilder<DefaultSource>.() -> Unit
-): T =
-    then(literal(name, block))
+): LiteralCommandNode<DefaultSource> =
+    then(literal(name), block) as LiteralCommandNode<DefaultSource>
 
 
 fun <T : ArgumentBuilder<DefaultSource, T>> T.thenLiteralExecute(
     name: String,
     block: CommandContext<DefaultSource>.() -> Unit
-): T =
+): LiteralCommandNode<DefaultSource> =
     thenLiteral(name) {
         thenExecute(block)
     }
 
-fun <T : ArgumentBuilder<DefaultSource, T>> T.then(node: ArgumentBuilder<DefaultSource, *>, block: T.() -> Unit): T =
-    then(node).also(block)
+fun <T : ArgumentBuilder<DefaultSource, T>, U : ArgumentBuilder<DefaultSource, U>> T.then(
+    node: U,
+    block: U.() -> Unit
+): CommandNode<DefaultSource> =
+    node.also(block).build().also(::then)
 
 fun <T : ArgumentBuilder<DefaultSource, T>> T.thenExecute(block: CommandContext<DefaultSource>.() -> Unit): T =
     executes {