improve calculation of ground level

Signed-off-by: Octol1ttle <[email protected]>

Author: Octol1ttle

src/main/kotlin/ru/octol1ttle/flightassistant/api/autoflight/ControlInput.kt

@@ -38,7 +38,7 @@ data class ControlInput(val target: Float, val text: Component? = null, val prio
             fun highest(first: Status?, second: Status?): Status {
                 if (first == null) return second ?: DISABLED
                 if (second == null) return first
-                return if (first < second) first else second
+                return if (first <= second) first else second
             }
 
             fun fromBooleans(active: Boolean, available: Boolean = true, enabled: Boolean = true): Status {

src/main/kotlin/ru/octol1ttle/flightassistant/config/options/SafetyOptions.kt

@@ -105,6 +105,10 @@ class SafetyOptions {
         this.obstacleAutoThrust = false
         this.obstacleAutoPitch = false
 
+        this.altitudeLossAlert = false
+        this.unsafeTerrainClearanceAlert = false
+        this.belowGlideSlopeAlertMode = AlertMode.DISABLED
+
         this.fireworkExplosiveAlert = false
         this.fireworkLockExplosive = false
         return this
@@ -160,7 +164,7 @@ class SafetyOptions {
         }
 
         companion object {
-            fun min(a: AlertMethod, b: AlertMethod): AlertMethod {
+            fun max(a: AlertMethod, b: AlertMethod): AlertMethod {
                 return if (a <= b) a else b
             }
         }

src/main/kotlin/ru/octol1ttle/flightassistant/impl/alert/flight_plan/DepartureElevationDisagreeAlert.kt

@@ -21,7 +21,7 @@ class DepartureElevationDisagreeAlert(computers: ComputerBus) : Alert(computers)
         }
         val x = computers.plan.departureData.coordinatesX
         val z = computers.plan.departureData.coordinatesZ
-        if (!computers.data.isChunkLoaded(x, z)) {
+        if (!computers.chunk.isLoaded(x, z)) {
             return false
         }
         val actualElevation: Int = computers.data.level.getHeight(Heightmap.Types.MOTION_BLOCKING, x, z)

src/main/kotlin/ru/octol1ttle/flightassistant/impl/alert/gpws/BelowGlideSlopeWarningAlert.kt

@@ -26,7 +26,7 @@ class BelowGlideSlopeWarningAlert(computers: ComputerBus) : Alert(computers), Ce
             return false
         }
 
-        val altitudeAboveGround = computers.data.altitude - (computers.data.groundY ?: return false)
+        val altitudeAboveGround = computers.data.altitude - (computers.gpws.groundY ?: return false)
         val glideSlopeDeviation = computers.plan.getCurrentGlideSlopeTarget()!! - computers.data.altitude
         return altitudeAboveGround < glideSlopeDeviation
     }

src/main/kotlin/ru/octol1ttle/flightassistant/impl/alert/gpws/PullUpAlert.kt

@@ -28,7 +28,7 @@ class PullUpAlert(computers: ComputerBus) : Alert(computers), CenteredAlert {
         return if (computers.gpws.groundImpactStatus < computers.gpws.obstacleImpactStatus) {
             FAConfig.safety.sinkRateAlertMethod
         } else if (computers.gpws.groundImpactStatus == computers.gpws.obstacleImpactStatus) {
-            SafetyOptions.AlertMethod.min(FAConfig.safety.sinkRateAlertMethod, FAConfig.safety.obstacleAlertMethod)
+            SafetyOptions.AlertMethod.max(FAConfig.safety.sinkRateAlertMethod, FAConfig.safety.obstacleAlertMethod)
         } else {
             FAConfig.safety.obstacleAlertMethod
         }

src/main/kotlin/ru/octol1ttle/flightassistant/impl/computer/autoflight/FlightPlanComputer.kt

@@ -145,7 +145,7 @@ class FlightPlanComputer(computers: ComputerBus) : Computer(computers) {
         }
         val minimums =
             if (arrivalData.minimumsType == ArrivalData.MinimumsType.ABSOLUTE) arrivalData.minimums.toDouble()
-            else (computers.data.groundY ?: computers.data.voidY.toDouble()) + arrivalData.minimums
+            else computers.gpws.groundOrVoidY + arrivalData.minimums
         return computers.data.altitude <= minimums
     }
 
@@ -231,6 +231,7 @@ class FlightPlanComputer(computers: ComputerBus) : Computer(computers) {
 
     override fun reset() {
         currentPhase = FlightPhase.UNKNOWN
+        groundSpeeds.clear()
     }
 
     companion object {

src/main/kotlin/ru/octol1ttle/flightassistant/impl/computer/data/AirDataComputer.kt

@@ -5,14 +5,10 @@ import kotlin.math.max
 import net.minecraft.client.Minecraft
 import net.minecraft.client.multiplayer.ClientLevel
 import net.minecraft.client.player.LocalPlayer
-import net.minecraft.core.Direction
 import net.minecraft.resources.ResourceLocation
 import net.minecraft.tags.DamageTypeTags
 import net.minecraft.util.Mth
 import net.minecraft.world.damagesource.DamageSource
-import net.minecraft.world.level.ClipContext
-import net.minecraft.world.phys.BlockHitResult
-import net.minecraft.world.phys.HitResult
 import net.minecraft.world.phys.Vec3
 import ru.octol1ttle.flightassistant.FlightAssistant
 import ru.octol1ttle.flightassistant.api.computer.Computer
@@ -41,18 +37,14 @@ class AirDataComputer(computers: ComputerBus, private val mc: Minecraft) : Compu
         get() = position.y
     val voidY: Int
         get() = level.bottomY - 64
-    var groundY: Double? = null
-        private set(value) {
-            field = value?.throwIfNotInRange(level.bottomY.toDouble()..Double.MAX_VALUE)
-        }
 
     private val fallDistance: Double
         get() =
-            if (groundY == null || groundY!! == Double.MAX_VALUE) Double.MAX_VALUE
+            if (computers.gpws.groundY == null || computers.gpws.groundY!! == Double.MAX_VALUE) Double.MAX_VALUE
 //? if >=1.21.5 {
             /*else max(player.fallDistance, altitude - groundY!!)
 *///?} else
-            else max(player.fallDistance.toDouble(), altitude - groundY!!)
+            else max(player.fallDistance.toDouble(), altitude - computers.gpws.groundY!!)
 
     val fallDistanceSafe: Boolean
         get() = player.isInWater || fallDistance <= player.maxFallDistance || isInvulnerableTo(player.damageSources().fall())
@@ -79,7 +71,6 @@ class AirDataComputer(computers: ComputerBus, private val mc: Minecraft) : Compu
         get() = degrees(asin(velocity.normalize().y).toFloat())
 
     override fun tick() {
-        groundY = computeGroundLevel()
         forwardVelocity = computeForwardVector(velocity)
         forwardVelocityPerSecond = forwardVelocity.perSecond()
         forwardAcceleration = forwardVelocity.length() - computeForwardVector(player.getDeltaMovementLerped(0.0f)).length()
@@ -101,36 +92,15 @@ class AirDataComputer(computers: ComputerBus, private val mc: Minecraft) : Compu
                 || player.abilities.mayfly && source.`is`(DamageTypeTags.IS_FALL)
     }
 
-    private fun computeGroundLevel(): Double? {
-        if (!computers.chunk.isCurrentLoaded) {
-            return groundY
-        }
-
-        val minY: Double = level.bottomY.toDouble().coerceAtLeast(altitude - 2500)
-        val result: BlockHitResult = level.clip(
-            ClipContext(
-                position,
-                position.with(Direction.Axis.Y, minY),
-                ClipContext.Block.COLLIDER,
-                ClipContext.Fluid.ANY,
-                player
-            )
-        )
-        if (result.type == HitResult.Type.MISS) {
-            return if (result.location.y > level.bottomY) Double.MAX_VALUE else null
-        }
-        return result.location.y
-    }
-
     fun computeForwardVector(vector: Vec3): Vec3 {
         val normalizedLookAngle: Vec3 = player.lookAngle.normalize()
         val normalizedVector: Vec3 = vector.normalize()
         return vector.scale(normalizedLookAngle.dot(normalizedVector).coerceAtLeast(0.0))
     }
 
     override fun reset() {
-        groundY = null
         forwardVelocity = Vec3.ZERO
+        forwardVelocityPerSecond = Vec3.ZERO
         forwardAcceleration = 0.0
     }
 

src/main/kotlin/ru/octol1ttle/flightassistant/impl/computer/safety/GroundProximityComputer.kt

@@ -3,6 +3,7 @@ package ru.octol1ttle.flightassistant.impl.computer.safety
 import kotlin.math.max
 import net.minecraft.network.chat.Component
 import net.minecraft.resources.ResourceLocation
+import net.minecraft.world.entity.Entity
 import net.minecraft.world.level.ClipContext
 import net.minecraft.world.level.levelgen.Heightmap
 import net.minecraft.world.phys.BlockHitResult
@@ -16,6 +17,7 @@ import ru.octol1ttle.flightassistant.api.autoflight.thrust.ThrustControllerRegis
 import ru.octol1ttle.flightassistant.api.computer.Computer
 import ru.octol1ttle.flightassistant.api.computer.ComputerBus
 import ru.octol1ttle.flightassistant.api.computer.ComputerQuery
+import ru.octol1ttle.flightassistant.api.util.extensions.bottomY
 import ru.octol1ttle.flightassistant.api.util.inverseMin
 import ru.octol1ttle.flightassistant.api.util.throwIfNotInRange
 import ru.octol1ttle.flightassistant.config.FAConfig
@@ -30,12 +32,21 @@ class GroundProximityComputer(computers: ComputerBus) : Computer(computers), Fli
     var obstacleImpactStatus: Status = Status.SAFE
         private set
 
+    var groundY: Double? = null
+    val groundOrVoidY: Double
+        get() = if (groundY == null || groundY == Double.MAX_VALUE) computers.data.voidY.toDouble()
+        else groundY!!
+
     override fun subscribeToEvents() {
         ThrustControllerRegistrationCallback.EVENT.register { it.accept(this) }
         PitchControllerRegistrationCallback.EVENT.register { it.accept(this) }
     }
 
     override fun tick() {
+        if (computers.chunk.isCurrentLoaded) {
+            groundY = computeGroundY()?.throwIfNotInRange(computers.data.level.bottomY.toDouble()..Double.MAX_VALUE)
+        }
+
         val data: AirDataComputer = computers.data
         if (!data.flying || data.player.isInWater) {
             groundImpactStatus = Status.SAFE
@@ -84,16 +95,22 @@ class GroundProximityComputer(computers: ComputerBus) : Computer(computers), Fli
             }
     }
 
+    private fun computeGroundY(): Double? {
+        val playerBoundingBox = computers.data.player.boundingBox
+        val minY: Double = computers.data.level.bottomY.toDouble().coerceAtLeast(computers.data.altitude - 2500.0)
+        val diffFromMinY = Vec3(0.0, minY - playerBoundingBox.minY, 0.0)
+        val collisionResult = Entity.collideBoundingBox(computers.data.player, diffFromMinY, playerBoundingBox, computers.data.level, emptyList())
+        if (collisionResult == diffFromMinY) {
+            return null
+        }
+        return collisionResult.y + playerBoundingBox.minY
+    }
+
     private fun computeGroundImpactTime(data: AirDataComputer): Double {
         if (data.velocity.y >= 0.0) {
             return Double.MAX_VALUE
         }
-
-        val groundLevel: Double? = data.groundY
-        val impactLevel: Double =
-            if (groundLevel == null || groundLevel == Double.MAX_VALUE) data.voidY.toDouble()
-            else groundLevel
-        return max(0.0, data.altitude - impactLevel) / -data.velocityPerSecond.y
+        return max(0.0, data.altitude - groundOrVoidY) / -data.velocityPerSecond.y
     }
 
     private fun computeObstacleImpactTime(data: AirDataComputer, lookAheadTime: Double): Double {
@@ -173,6 +190,7 @@ class GroundProximityComputer(computers: ComputerBus) : Computer(computers), Fli
         groundImpactStatus = Status.SAFE
         obstacleImpactTime = Double.MAX_VALUE
         obstacleImpactStatus = Status.SAFE
+        groundY = null
     }
 
     enum class Status {

src/main/kotlin/ru/octol1ttle/flightassistant/impl/computer/safety/VoidProximityComputer.kt

@@ -24,7 +24,7 @@ class VoidProximityComputer(computers: ComputerBus) : Computer(computers), Fligh
     }
 
     override fun tick() {
-        status = if (computers.data.groundY != null) {
+        status = if (computers.gpws.groundY != null) {
             Status.ABOVE_GROUND
         } else {
             val heightAboveDamageAltitude: Double = computers.data.altitude - computers.data.voidY

src/main/kotlin/ru/octol1ttle/flightassistant/impl/display/RadarAltitudeDisplay.kt

@@ -19,8 +19,8 @@ class RadarAltitudeDisplay(computers: ComputerBus) : Display(computers) {
     }
 
     override fun render(guiGraphics: GuiGraphics) {
-        val groundLevel: Double? = computers.data.groundY
-        if (!computers.data.isCurrentChunkLoaded || groundLevel != null && groundLevel > computers.hudData.lerpedAltitude) {
+        val groundLevel: Double? = computers.gpws.groundY
+        if (!computers.chunk.isCurrentLoaded || groundLevel != null && groundLevel > computers.hudData.lerpedAltitude) {
             renderFaulted(guiGraphics)
             return
         }