feat: add new Griffin Burrow guess method based on spade

Author: My-Name-Is-Jeff

src/main/kotlin/gg/skytils/skytilsmod/commands/impl/SkytilsCommand.kt

@@ -110,6 +110,9 @@ object SkytilsCommand : BaseCommand("skytils", listOf("st")) {
                     "refresh" -> {
                         GriffinBurrows.particleBurrows.clear()
                     }
+                    "clearguess" -> {
+                        GriffinBurrows.BurrowEstimation.guesses.clear()
+                    }
 
                     else -> UChat.chat("$prefix §b/skytils griffin <refresh>")
                 }

src/main/kotlin/gg/skytils/skytilsmod/core/Config.kt

@@ -1577,6 +1577,13 @@ object Config : Vigilant(
     )
     var burrowEstimation = false
 
+    @Property(
+        type = PropertyType.SWITCH, name = "Griffin Burrow Estimation (MEOW)",
+        description = "Estimates griffin burrow position after using spade ANYWHERE. Use of this mode will disable the other mode.",
+        category = "Events", subcategory = "Mythological"
+    )
+    var experimentBurrowEstimation = false
+
     @Property(
         type = PropertyType.SWITCH, name = "Broadcast Rare Drop Notifications",
         description = "Sends rare drop notification when you obtain a rare drop from a Mythological Creature.",
@@ -4385,7 +4392,8 @@ object Config : Vigilant(
             "mobBurrowColor",
             "treasureBurrowColor",
             "burrowEstimation",
-            "pingNearbyBurrow"
+            "pingNearbyBurrow",
+            "experimentBurrowEstimation"
         ).forEach { propertyName -> addDependency(propertyName, "showGriffinBurrows") }
 
         addDependency("activePetColor", "highlightActivePet")

src/main/kotlin/gg/skytils/skytilsmod/features/impl/events/GriffinBurrows.kt

@@ -46,20 +46,23 @@ import net.minecraftforge.fml.common.gameevent.TickEvent.ClientTickEvent
 import java.awt.Color
 import java.time.Duration
 import java.time.Instant
-import kotlin.math.PI
-import kotlin.math.cos
-import kotlin.math.sin
+import kotlin.math.*
 
 object GriffinBurrows {
     val particleBurrows = hashMapOf<BlockPos, ParticleBurrow>()
     var lastDugParticleBurrow: BlockPos? = null
     val recentlyDugParticleBurrows = EvictingQueue.create<BlockPos>(5)
 
     var hasSpadeInHotbar = false
+    var lastSpadeUse = -1L
 
     object BurrowEstimation {
         val arrows = mutableMapOf<Arrow, Instant>()
         val guesses = mutableMapOf<BurrowGuess, Instant>()
+        val lastTrail = mutableListOf<Vec3>()
+        var lastTrailCreated = -1L
+        var firstDistanceGuess = 0.0
+
         fun getDistanceFromPitch(pitch: Double) =
             2805 * pitch - 1375
 
@@ -70,7 +73,6 @@ object GriffinBurrows {
         class Arrow(val directionVector: Vec3, val pos: Vec3)
     }
 
-
     @SubscribeEvent
     fun onTick(event: ClientTickEvent) {
         if (event.phase != TickEvent.Phase.START) return
@@ -84,6 +86,69 @@ object GriffinBurrows {
         BurrowEstimation.arrows.entries.removeIf { (_, instant) ->
             Duration.between(instant, Instant.now()).toMillis() > 30_000L
         }
+        if (!Skytils.config.experimentBurrowEstimation) return
+        if (BurrowEstimation.firstDistanceGuess != -1.0 && BurrowEstimation.lastTrail.size >= 2 && System.currentTimeMillis() - BurrowEstimation.lastTrailCreated > 1000) {
+            printDevMessage("Trail found ${BurrowEstimation.lastTrail}", "griffinguess")
+            printDevMessage("Pitch ${BurrowEstimation.firstDistanceGuess}", "griffinguess")
+
+            val pitch = BurrowEstimation.firstDistanceGuess
+
+            fun cubicFunc(x: Double): Double {
+                return -355504.3762671333 * x.pow(3) + 573210.5260410917 * x.pow(2) - 304839.7095941929 * x + 53581.7430868503
+            }
+
+            fun logFunc(x: Double): Double {
+                return 1018.3988994912 + 3301.6178248206 * log10(x)
+            }
+
+            fun linearFunc(x: Double): Double {
+                return 2760.6568614981 * x - 1355.0749724848
+            }
+
+            val distanceGuessLog = logFunc(pitch)
+            val distanceGuessC = cubicFunc(pitch)
+            val distanceGuessL = linearFunc(pitch)
+
+            val distanceGuess = if (pitch < 0.5) distanceGuessC else if (pitch > .6) (distanceGuessLog + .1 * distanceGuessL) else {
+                .45 * distanceGuessC + .5 * distanceGuessLog + (if (pitch > .53) .1 else .05) * distanceGuessL
+            }
+
+            printDevMessage("Distance guess cubic $distanceGuessC log $distanceGuessLog, weighted $distanceGuess", "griffinguess")
+
+            val trail = BurrowEstimation.lastTrail.asReversed()
+
+            val directionVector = trail[0].subtract(trail[1]).normalize()
+            printDevMessage("Direction vector $directionVector", "griffinguess")
+
+            val guessPos = trail.last().add(
+                directionVector * distanceGuess
+            )
+            printDevMessage("Guess pos $guessPos", "griffinguess")
+
+            println("Pitch ${pitch}, Distance: ${
+                particleBurrows.keys.minOfOrNull {
+                    trail.last().distanceTo(it.toVec3())
+                }
+            }")
+
+            var y: Int
+            var x = guessPos.x.toInt()
+            var z = guessPos.z.toInt()
+            // offset of 300 blocks for both x and z
+            // x ranges from 195 to -281
+            // z ranges from 207 to -233
+
+            // TODO: this y thing is wrong and puts them in the air sometimes
+            do {
+                y = BurrowEstimation.grassData.getOrNull((x++ % 507) * 507 + (z++ % 495))?.toInt() ?: 0
+            } while (y < 2)
+            val guess = BurrowGuess(guessPos.x.toInt(), y, guessPos.z.toInt())
+            BurrowEstimation.guesses[guess] = Instant.now()
+
+            BurrowEstimation.lastTrail.clear()
+            BurrowEstimation.lastTrailCreated = -1
+            BurrowEstimation.firstDistanceGuess = -1.0
+        }
     }
 
     @SubscribeEvent(receiveCanceled = true, priority = EventPriority.HIGHEST)
@@ -110,24 +175,38 @@ object GriffinBurrows {
             lastDugParticleBurrow = null
             BurrowEstimation.guesses.clear()
             BurrowEstimation.arrows.clear()
+            BurrowEstimation.lastTrail.clear()
+            BurrowEstimation.lastTrailCreated = -1
+            lastSpadeUse = -1
+            BurrowEstimation.firstDistanceGuess = -1.0
         }
     }
 
     @SubscribeEvent
     fun onSendPacket(event: PacketEvent.SendEvent) {
-        if (!Utils.inSkyblock || !Skytils.config.showGriffinBurrows || mc.theWorld == null || mc.thePlayer == null) return
-        val pos =
-            when {
-                event.packet is C07PacketPlayerDigging && event.packet.status == C07PacketPlayerDigging.Action.START_DESTROY_BLOCK -> {
-                    event.packet.position
+        if (!Utils.inSkyblock || !Skytils.config.showGriffinBurrows || mc.thePlayer == null || SBInfo.mode != SkyblockIsland.Hub.mode) return
+        if (mc.thePlayer.heldItem?.isSpade != true) return
+
+        if (event.packet is C08PacketPlayerBlockPlacement && event.packet.position.y == -1) {
+            lastSpadeUse = System.currentTimeMillis()
+            BurrowEstimation.lastTrail.clear()
+            BurrowEstimation.lastTrailCreated = -1
+            BurrowEstimation.firstDistanceGuess = -1.0
+            printDevMessage("Spade used", "griffinguess")
+        } else {
+            val pos =
+                when {
+                    event.packet is C07PacketPlayerDigging && event.packet.status == C07PacketPlayerDigging.Action.START_DESTROY_BLOCK -> {
+                        event.packet.position
+                    }
+                    event.packet is C08PacketPlayerBlockPlacement && event.packet.stack != null -> event.packet.position
+                    else -> return
                 }
-                event.packet is C08PacketPlayerBlockPlacement && event.packet.stack != null -> event.packet.position
-                else -> return
+            if (mc.theWorld.getBlockState(pos).block !== Blocks.grass) return
+            particleBurrows[pos]?.blockPos?.let {
+                printDevMessage("Clicked on $it", "griffin")
+                lastDugParticleBurrow = it
             }
-        if (mc.thePlayer.heldItem?.isSpade != true || mc.theWorld.getBlockState(pos).block !== Blocks.grass) return
-        particleBurrows[pos]?.blockPos?.let {
-            printDevMessage("Clicked on $it", "griffin")
-            lastDugParticleBurrow = it
         }
     }
 
@@ -176,41 +255,47 @@ object GriffinBurrows {
                 if (Skytils.config.showGriffinBurrows && hasSpadeInHotbar) {
                     if (SBInfo.mode != SkyblockIsland.Hub.mode) return
                     event.packet.apply {
-                        val type = ParticleType.getParticleType(this) ?: return
-                        val pos = BlockPos(x, y, z).down()
-                        if (recentlyDugParticleBurrows.contains(pos)) return
-                        BurrowEstimation.guesses.keys.associateWith { guess ->
-                            pos.distanceSq(
-                                guess.x.toDouble(),
-                                guess.y.toDouble(),
-                                guess.z.toDouble()
-                            )
-                        }.minByOrNull { it.value }?.let { (guess, distance) ->
-                            printDevMessage("Nearest guess is $distance blocks away", "griffin", "griffinguess")
-                            if (distance <= 625) {
-                                BurrowEstimation.guesses.remove(guess)
+                        if (type == EnumParticleTypes.DRIP_LAVA && count == 2 && speed == -.5f && xOffset == 0f && yOffset == 0f && zOffset == 0f && isLongDistance) {
+                            BurrowEstimation.lastTrail.add(vec3)
+                            BurrowEstimation.lastTrailCreated = System.currentTimeMillis()
+                            printDevMessage("Found trail point $x $y $z", "griffinguess")
+                        } else {
+                            val type = ParticleType.getParticleType(this) ?: return
+                            val pos = BlockPos(x, y, z).down()
+                            if (recentlyDugParticleBurrows.contains(pos)) return
+                            BurrowEstimation.guesses.keys.associateWith { guess ->
+                                pos.distanceSq(
+                                    guess.x.toDouble(),
+                                    guess.y.toDouble(),
+                                    guess.z.toDouble()
+                                )
+                            }.minByOrNull { it.value }?.let { (guess, distance) ->
+                                // printDevMessage("Nearest guess is $distance blocks^2 away", "griffin", "griffinguess")
+                                if (distance <= 625) {
+                                    BurrowEstimation.guesses.remove(guess)
+                                }
                             }
-                        }
-                        val burrow = particleBurrows.getOrPut(pos) {
-                            ParticleBurrow(pos, hasFootstep = false, hasEnchant = false)
-                        }
-                        if (burrow.type == -1 && type.isBurrowType) {
-                            if (Skytils.config.pingNearbyBurrow) {
-                                SoundQueue.addToQueue("random.orb", 0.8f, 1f, 0, true)
+                            val burrow = particleBurrows.getOrPut(pos) {
+                                ParticleBurrow(pos, hasFootstep = false, hasEnchant = false)
+                            }
+                            if (burrow.type == -1 && type.isBurrowType) {
+                                if (Skytils.config.pingNearbyBurrow) {
+                                    SoundQueue.addToQueue("random.orb", 0.8f, 1f, 0, true)
+                                }
+                            }
+                            when (type) {
+                                ParticleType.FOOTSTEP -> burrow.hasFootstep = true
+                                ParticleType.ENCHANT -> burrow.hasEnchant = true
+                                ParticleType.EMPTY -> burrow.type = 0
+                                ParticleType.MOB -> burrow.type = 1
+                                ParticleType.TREASURE -> burrow.type = 2
                             }
-                        }
-                        when (type) {
-                            ParticleType.FOOTSTEP -> burrow.hasFootstep = true
-                            ParticleType.ENCHANT -> burrow.hasEnchant = true
-                            ParticleType.EMPTY -> burrow.type = 0
-                            ParticleType.MOB -> burrow.type = 1
-                            ParticleType.TREASURE -> burrow.type = 2
                         }
                     }
                 }
             }
             is S04PacketEntityEquipment -> {
-                if (!Skytils.config.burrowEstimation || SBInfo.mode != SkyblockIsland.Hub.mode) return
+                if (!Skytils.config.burrowEstimation || SBInfo.mode != SkyblockIsland.Hub.mode || Skytils.config.experimentBurrowEstimation) return
                 val entity = mc.theWorld?.getEntityByID(event.packet.entityID)
                 (entity as? EntityArmorStand)?.let { armorStand ->
                     if (event.packet.itemStack?.item != Items.arrow) return
@@ -229,7 +314,12 @@ object GriffinBurrows {
             }
             is S29PacketSoundEffect -> {
                 if (!Skytils.config.burrowEstimation || SBInfo.mode != SkyblockIsland.Hub.mode) return
-                if (event.packet.soundName != "note.harp") return
+                if (event.packet.soundName != "note.harp" || event.packet.volume != 1f) return
+                printDevMessage("Found note harp sound ${event.packet.pitch} ${event.packet.volume} ${event.packet.x} ${event.packet.y} ${event.packet.z}", "griffinguess")
+                if (BurrowEstimation.firstDistanceGuess == -1.0 && lastSpadeUse != -1L && System.currentTimeMillis() - lastSpadeUse < 1000) {
+                    BurrowEstimation.firstDistanceGuess = event.packet.pitch.toDouble()
+                }
+                if (Skytils.config.experimentBurrowEstimation) return
                 val (arrow, distance) = BurrowEstimation.arrows.keys
                     .associateWith { arrow ->
                         arrow.pos.squareDistanceTo(event.packet.x, event.packet.y, event.packet.z)