Merge remote-tracking branch 'droid/master' into GLES

# Conflicts:
#	src/com/rian/andengine/HUD.kt

Author: Acivev

src/com/osudroid/ui/v2/CalibrationScene.kt

@@ -5,7 +5,6 @@ import androidx.annotation.IdRes
 import com.edlplan.framework.easing.Easing
 import com.osudroid.ui.v1.SettingsFragment
 import com.osudroid.utils.mainThread
-import com.osudroid.utils.standardDeviation
 import com.osudroid.utils.updateThread
 import com.reco1l.andengine.Anchor
 import com.reco1l.andengine.UIEngine
@@ -38,8 +37,11 @@ import com.reco1l.framework.math.Vec4
 import com.reco1l.osu.ui.PromptDialog
 import com.osudroid.beatmaps.DroidHitWindow
 import com.osudroid.math.Interpolation
+import com.osudroid.utils.median
+import com.osudroid.utils.standardDeviation
 import com.rian.andengine.modifier.ModifierType
 import kotlin.math.abs
+import kotlin.math.exp
 import kotlin.math.roundToInt
 import org.andengine.input.touch.TouchEvent
 import ru.nsu.ccfit.zuev.audio.Status
@@ -547,7 +549,7 @@ object CalibrationScene : UIScene() {
             tapOffsets.removeAt(0)
         }
 
-        pendingOffset = tapOffsets.standardDeviation().roundToInt().coerceIn(OFFSET_MIN, OFFSET_MAX)
+        pendingOffset = computePendingOffset()
 
         val judgement = when {
             absErr < judgementHitWindow.greatWindow -> Judgement.PERFECT
@@ -784,4 +786,21 @@ object CalibrationScene : UIScene() {
         Config.setOffset(pendingOffset.toFloat())
         Config.setInt("offset", pendingOffset)
     }
+
+    private fun computePendingOffset(): Int {
+        if (tapOffsets.isEmpty()) {
+            return 0
+        }
+
+        val unstableRate = tapOffsets.standardDeviation()
+        var offset = tapOffsets.median()
+
+        if (unstableRate >= 90) {
+            // A demonstrative graph of this algorithm is embedded in https://github.com/ppy/osu/discussions/30521.
+            // This prevents high unstable rate from suggesting potentially invalid offsets.
+            offset *= exp(-0.0116 * (unstableRate - 90))
+        }
+
+        return offset.roundToInt().coerceIn(OFFSET_MIN, OFFSET_MAX)
+    }
 }

src/com/osudroid/ui/v2/hud/elements/HUDAverageOffsetCounter.kt

@@ -15,11 +15,11 @@ class HUDAverageOffsetCounter : HUDElement() {
         text = "Avg offset: 0ms"
     }
 
-    private var value = 0f
+    private var value = 0.0
         set(value) {
             if (field != value) {
                 field = value
-                text.text = "Avg offset: ${(value * 1000).roundToInt()}ms"
+                text.text = "Avg offset: ${value.roundToInt()}ms"
             }
         }
 
@@ -28,6 +28,6 @@ class HUDAverageOffsetCounter : HUDElement() {
     }
 
     override fun onGameplayUpdate(game: GameScene, secondsElapsed: Float) {
-        value = if (game.offsetRegs > 0) game.offsetSum / game.offsetRegs else 0f
+        value = game.stat.averageHitOffset
     }
 }

src/com/osudroid/ui/v2/modmenu/ModIcon.kt

@@ -37,6 +37,44 @@ class ModIcon(val mod: Mod) : UIContainer(), ISkinnable {
         return ResourceManager.getInstance().getTexture(mod.iconTextureName)?.takeUnless { it is BlankTextureRegion }
     }
 
+    private fun setupContent() {
+        detachChildren()
+
+        val texture = fetchTextureRegion()
+
+        if (texture != null) {
+            background = null
+
+            attachChild(OsuSkinnableSprite(mod.iconTextureName).apply {
+                width = FillParent
+                height = FillParent
+                buffer = sharedSpriteVBO
+            })
+        } else {
+            background = UIBox().apply {
+                applyTheme = { color = it.accentColor * 0.1f }
+            }
+
+            attachChild(UIText().apply {
+                anchor = Anchor.Center
+                origin = Anchor.Center
+                text = mod.acronym
+                font = ResourceManager.getInstance().getFont("smallFont")
+                applyTheme = { color = it.accentColor }
+            })
+        }
+
+        shouldUpdateTexture = false
+    }
+
+
+    override fun onAttached() {
+        if (shouldUpdateTexture) {
+            setupContent()
+        }
+
+        super.onAttached()
+    }
 
     override fun onManagedDraw(pGLState: GLState, pCamera: Camera) {
 
@@ -52,33 +90,7 @@ class ModIcon(val mod: Mod) : UIContainer(), ISkinnable {
 
     override fun onManagedUpdate(deltaTimeSec: Float) {
         if (shouldUpdateTexture) {
-            detachChildren()
-
-            val texture = fetchTextureRegion()
-
-            if (texture != null) {
-                background = null
-
-                attachChild(OsuSkinnableSprite(mod.iconTextureName).apply {
-                    width = FillParent
-                    height = FillParent
-                    buffer = sharedSpriteVBO
-                })
-            } else {
-                background = UIBox().apply {
-                    applyTheme = { color = it.accentColor * 0.1f }
-                }
-
-                attachChild(UIText().apply {
-                    anchor = Anchor.Center
-                    origin = Anchor.Center
-                    text = mod.acronym
-                    font = ResourceManager.getInstance().getFont("smallFont")
-                    applyTheme = { color = it.accentColor }
-                })
-            }
-
-            shouldUpdateTexture = false
+            setupContent()
         }
 
         super.onManagedUpdate(deltaTimeSec)

src/com/osudroid/utils/Collections.kt

@@ -14,4 +14,19 @@ fun Collection<Double>.standardDeviation(): Double {
     val mean = average()
 
     return sqrt(sumOf { (it - mean).pow(2) } / size)
+}
+
+/**
+ * Returns the median of the elements in this [Collection]. If the collection is empty, returns 0.
+ */
+fun Collection<Double>.median(): Double {
+    if (isEmpty()) {
+        return 0.0
+    }
+
+    val sorted = sorted()
+    val center = sorted.size / 2
+
+    // Use average of the 2 central values if the length is even.
+    return if (sorted.size % 2 == 0) (sorted[center - 1] + sorted[center]) / 2 else sorted[center]
 }

src/com/rian/andengine/HUD.kt

@@ -9,6 +9,8 @@ import com.rian.andengine.timing.IClockReceiver
 import com.rian.andengine.timing.IFrameBasedClock
 import org.andengine.engine.camera.hud.HUD as AndEngineHUD
 import org.andengine.entity.scene.Scene
+import org.andengine.engine.camera.Camera
+import javax.microedition.khronos.opengles.GL10
 
 /**
  * An [AndEngineHUD] that provides an [IFrameBasedClock] to its [UIComponent] children.
@@ -125,6 +127,34 @@ open class HUD : AndEngineHUD(), IClockProvider<IFrameBasedClock?>, IClockReceiv
 
     //endregion
 
+    private var hudCamera: Camera? = null
+
+    override fun onDraw(pGL: GL10, pCamera: Camera) {
+        val mc = mCamera
+        var cam = pCamera
+
+        // HUD should not be affected by camera zoom since it is displayed across all scenes (meaning it should fill the
+        // entire screen). However, CameraScene (which is what AndEngine's HUD extends) passes the zoomed main camera
+        // to children.
+        // We need to give children an un-zoomed camera, not just due to that, but to also ensure that clipping computes
+        // correct scissor regions in this HUD's space.
+        if (mc != null) {
+            val rawWidth = mc.widthRaw
+            val rawHeight = mc.heightRaw
+            var hudCamera = hudCamera
+
+            if (hudCamera == null || hudCamera.widthRaw != rawWidth || hudCamera.heightRaw != rawHeight) {
+                hudCamera = Camera(0f, 0f, rawWidth, rawHeight)
+                this.hudCamera = hudCamera
+            }
+
+            hudCamera.setSurfaceSize(0, 0, pCamera.surfaceWidth, pCamera.surfaceHeight)
+            cam = hudCamera
+        }
+
+        super.onDraw(pGL, cam)
+    }
+
     override fun setChildScene(childScene: Scene?, modalDraw: Boolean, modalUpdate: Boolean, modalTouch: Boolean) {
         this.childScene?.onDetached()
         super.setChildScene(childScene, modalDraw, modalUpdate, modalTouch)

src/ru/nsu/ccfit/zuev/osu/game/GameObjectListener.java

@@ -49,8 +49,8 @@ void onSliderHit(int id, int score, PointF judgementPos,
     float getElapsedTime();
 
     /**
-     * Whether the game has just seeked and is in the first frame where active objects run their first update.
-     * Used to suppress hitsounds for nested slider objects that were already passed at the seek target.
+     * Whether the game has recently seeked and active objects are still in the catch-up frames.
+     * Used to suppress hitsounds for slider objects (head, ticks, repeats) that were already passed at the seek target.
      */
     boolean isAfterSeek();
 }