feat(statistics): store ranked_score & total_score under classic scoring mode (#68)

* Initial plan * feat(calculator): add classic score simulator and scoring mode support - Add ScoringMode enum with STANDARDISED and CLASSIC modes - Add scoring_mode configuration to game settings - Implement GetDisplayScore function in calculator.py - Add get_display_score method to Score model - Update score statistics to use display scores based on scoring mode Co-authored-by: MingxuanGame <68982190+MingxuanGame@users.noreply.github.com> * fix(calculator): apply scoring mode to TotalScoreBestScore delete method - Update delete method to use display score for consistency - Ensures all UserStatistics modifications use configured scoring mode Co-authored-by: MingxuanGame <68982190+MingxuanGame@users.noreply.github.com> * refactor(calculator): address code review feedback - Move MAX_SCORE constant to app/const.py - Implement is_basic() as method in HitResult enum - Move imports to top of file in Score model - Revert TotalScoreBestScore storage to use standardised score - Apply display score calculation in tools/recalculate.py - Keep display score usage in UserStatistics modifications Co-authored-by: MingxuanGame <68982190+MingxuanGame@users.noreply.github.com> * chore(linter): auto fix by pre-commit hooks * Don't use forward-ref for `ScoringMode` * chore(linter): auto fix by pre-commit hooks * fix(calculator): update HitResult usage in get_display_score and adjust ruleset value in PerformanceServerPerformanceCalculator --------- Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com> Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com> Co-authored-by: MingxuanGame <MingxuanGame@outlook.com>
2025-11-08 20:56:29 +08:00
parent ef3a900de0
commit d9d26d0523
9 changed files with 144 additions and 9 deletions
--- a/app/calculator.py
+++ b/app/calculator.py
@@ -6,8 +6,10 @@ from typing import TYPE_CHECKING

 from app.calculators.performance import PerformanceCalculator
 from app.config import settings
+from app.const import MAX_SCORE
 from app.log import log
-from app.models.score import GameMode
+from app.models.score import GameMode, HitResult, ScoreStatistics
+from app.models.scoring_mode import ScoringMode

 from osupyparser import HitObject, OsuFile
 from osupyparser.osu.objects import Slider
@@ -52,6 +54,57 @@ def clamp[T: int | float](n: T, min_value: T, max_value: T) -> T:
        return n


+def get_display_score(ruleset_id: int, total_score: int, mode: ScoringMode, maximum_statistics: ScoreStatistics) -> int:
+    """
+    Calculate the display score based on the scoring mode.
+
+    Based on: https://github.com/ppy/osu/blob/master/osu.Game/Scoring/Legacy/ScoreInfoExtensions.cs
+
+    Args:
+        ruleset_id: The ruleset ID (0=osu!, 1=taiko, 2=catch, 3=mania)
+        total_score: The standardised total score
+        mode: The scoring mode (standardised or classic)
+        maximum_statistics: Dictionary of maximum statistics for the score
+
+    Returns:
+        The display score in the requested scoring mode
+    """
+    if mode == ScoringMode.STANDARDISED:
+        return total_score
+
+    # Calculate max basic judgements
+    max_basic_judgements = sum(
+        count for hit_result, count in maximum_statistics.items() if HitResult(hit_result).is_basic()
+    )
+
+    return _convert_standardised_to_classic(ruleset_id, total_score, max_basic_judgements)
+
+
+def _convert_standardised_to_classic(ruleset_id: int, standardised_total_score: int, object_count: int) -> int:
+    """
+    Convert a standardised score to classic score.
+
+    The coefficients were determined by a least-squares fit to minimise relative error
+    of maximum possible base score across all beatmaps.
+
+    Args:
+        ruleset_id: The ruleset ID (0=osu!, 1=taiko, 2=catch, 3=mania)
+        standardised_total_score: The standardised total score
+        object_count: The number of basic hit objects
+
+    Returns:
+        The classic score
+    """
+    if ruleset_id == 0:  # osu!
+        return round((object_count**2 * 32.57 + 100000) * standardised_total_score / MAX_SCORE)
+    elif ruleset_id == 1:  # taiko
+        return round((object_count * 1109 + 100000) * standardised_total_score / MAX_SCORE)
+    elif ruleset_id == 2:  # catch
+        return round((standardised_total_score / MAX_SCORE * object_count) ** 2 * 21.62 + standardised_total_score / 10)
+    else:  # mania (ruleset_id == 3) or default
+        return standardised_total_score
+
+
 def calculate_pp_for_no_calculator(score: "Score", star_rating: float) -> float:
    # TODO: Improve this algorithm
    # https://www.desmos.com/calculator/i2aa7qm3o6
--- a/app/calculators/performance/performance_server.py
+++ b/app/calculators/performance/performance_server.py
@@ -106,7 +106,7 @@ class PerformanceServerPerformanceCalculator(BasePerformanceCalculator):
                            "small_tick_hit": score.nsmall_tick_hit or 0,
                            "slider_tail_hit": score.nslider_tail_hit or 0,
                        },
-                        "ruleset": score.gamemode.value,
+                        "ruleset": score.gamemode.to_base_ruleset().value,
                    },
                )
                if resp.status_code != 200:
--- a/app/config.py
+++ b/app/config.py
@@ -1,6 +1,8 @@
 from enum import Enum
 from typing import Annotated, Any, Literal

+from app.models.scoring_mode import ScoringMode
+
 from pydantic import (
    AliasChoices,
    Field,
@@ -521,6 +523,14 @@ CALCULATOR_CONFIG='{
        ),
        "游戏设置",
    ]
+    scoring_mode: Annotated[
+        ScoringMode,
+        Field(
+            default=ScoringMode.STANDARDISED,
+            description="分数计算模式：standardised（标准化）或 classic（经典）",
+        ),
+        "游戏设置",
+    ]

    # 表现计算设置
    calculator: Annotated[
--- a/app/const.py
+++ b/app/const.py
@@ -3,3 +3,7 @@ BANCHOBOT_ID = 2
 BACKUP_CODE_LENGTH = 10

 SUPPORT_TOTP_VERIFICATION_VER = 20250913
+
+# Maximum score in standardised scoring mode
+# https://github.com/ppy/osu/blob/master/osu.Game/Rulesets/Scoring/ScoreProcessor.cs
+MAX_SCORE = 1000000
--- a/app/database/score.py
+++ b/app/database/score.py
@@ -11,6 +11,7 @@ from app.calculator import (
    calculate_weighted_acc,
    calculate_weighted_pp,
    clamp,
+    get_display_score,
    pre_fetch_and_calculate_pp,
 )
 from app.config import settings
@@ -34,6 +35,7 @@ from app.models.score import (
    ScoreStatistics,
    SoloScoreSubmissionInfo,
 )
+from app.models.scoring_mode import ScoringMode
 from app.storage import StorageService
 from app.utils import utcnow

@@ -223,6 +225,26 @@ class Score(ScoreBase, table=True):
    def replay_filename(self) -> str:
        return f"replays/{self.id}_{self.beatmap_id}_{self.user_id}_lazer_replay.osr"

+    def get_display_score(self, mode: ScoringMode | None = None) -> int:
+        """
+        Get the display score for this score based on the scoring mode.
+
+        Args:
+            mode: The scoring mode to use. If None, uses the global setting.
+
+        Returns:
+            The display score in the requested scoring mode
+        """
+        if mode is None:
+            mode = settings.scoring_mode
+
+        return get_display_score(
+            ruleset_id=int(self.gamemode),
+            total_score=self.total_score,
+            mode=mode,
+            maximum_statistics=self.maximum_statistics,
+        )
+
    async def to_resp(self, session: AsyncSession, api_version: int) -> "ScoreResp | LegacyScoreResp":
        if api_version >= 20220705:
            return await ScoreResp.from_db(session, self)
@@ -1108,12 +1130,17 @@ async def _process_statistics(
        raise ValueError(f"User {user.id} does not have statistics for mode {score.gamemode.value}")

    # pc, pt, tth, tts
-    statistics.total_score += score.total_score
-    difference = score.total_score - previous_score_best.total_score if previous_score_best else score.total_score
+    # Get display scores based on configured scoring mode
+    current_display_score = score.get_display_score()
+    previous_display_score = previous_score_best.score.get_display_score() if previous_score_best else 0
+
+    statistics.total_score += current_display_score
+    difference = current_display_score - previous_display_score
    logger.debug(
-        "Score delta computed for {score_id}: {difference}",
+        "Score delta computed for {score_id}: {difference} (display score in {mode} mode)",
        score_id=score.id,
        difference=difference,
+        mode=settings.scoring_mode,
    )
    if difference > 0 and score.passed and ranked:
        match score.rank:
--- a/app/database/total_score_best_scores.py
+++ b/app/database/total_score_best_scores.py
@@ -56,8 +56,10 @@ class TotalScoreBestScore(SQLModel, table=True):
        )
        statistics = statistics.first()
        if statistics:
-            statistics.total_score -= self.total_score
-            statistics.ranked_score -= self.total_score
+            # Use display score from the referenced score for consistency with current scoring mode
+            display_score = self.score.get_display_score()
+            statistics.total_score -= display_score
+            statistics.ranked_score -= display_score
            statistics.level_current = calculate_score_to_level(statistics.total_score)
            match self.rank:
                case Rank.X:
--- a/app/models/score.py
+++ b/app/models/score.py
@@ -251,6 +251,28 @@ class HitResult(str, Enum):
            HitResult.IGNORE_MISS,
        )

+    def is_basic(self) -> bool:
+        """
+        Check if a HitResult is a basic (non-tick, non-bonus) result.
+
+        Based on: https://github.com/ppy/osu/blob/master/osu.Game/Rulesets/Scoring/HitResult.cs
+        """
+        if self in {HitResult.LEGACY_COMBO_INCREASE, HitResult.COMBO_BREAK}:
+            return False
+
+        # Check if it's scorable and not a tick or bonus
+        is_tick = self in {
+            HitResult.LARGE_TICK_HIT,
+            HitResult.LARGE_TICK_MISS,
+            HitResult.SMALL_TICK_HIT,
+            HitResult.SMALL_TICK_MISS,
+            HitResult.SLIDER_TAIL_HIT,
+        }
+
+        is_bonus = self in {HitResult.SMALL_BONUS, HitResult.LARGE_BONUS}
+
+        return self.is_scorable() and not is_tick and not is_bonus
+

 class LeaderboardType(Enum):
    GLOBAL = "global"
--- a/app/models/scoring_mode.py
+++ b/app/models/scoring_mode.py
@@ -0,0 +1,13 @@
+from enum import Enum
+
+
+class ScoringMode(str, Enum):
+    """
+    Scoring mode for calculating scores.
+
+    STANDARDISED: Modern scoring mode used in current osu!lazer
+    CLASSIC: Legacy scoring mode for backward compatibility
+    """
+
+    STANDARDISED = "standardised"
+    CLASSIC = "classic"
--- a/tools/recalculate.py
+++ b/tools/recalculate.py
@@ -374,7 +374,9 @@ async def _recalculate_statistics(
            continue

        statistics.play_count += 1
-        statistics.total_score += score.total_score
+        # Use display score based on configured scoring mode
+        display_score = score.get_display_score()
+        statistics.total_score += display_score

        playtime, is_valid = calculate_playtime(score, beatmap.hit_length)
        if is_valid:
@@ -390,7 +392,9 @@ async def _recalculate_statistics(
        if ranked and score.passed:
            statistics.maximum_combo = max(statistics.maximum_combo, score.max_combo)
            previous = cached_best.get(score.beatmap_id)
-            difference = score.total_score - (previous.total_score if previous else 0)
+            # Calculate difference using display scores
+            previous_display = previous.get_display_score() if previous else 0
+            difference = display_score - previous_display
            if difference > 0:
                cached_best[score.beatmap_id] = score
                statistics.ranked_score += difference