Funkin/source/funkin/play/scoring/Scoring.hx

package funkin.play.scoring;

enum abstract ScoringSystem(String)
{
  /**
   * The scoring system used in versions of the game Week 6 and older.
   * Scores the player based on judgement, represented by a step function.
   */
  var LEGACY;

  /**
   * The scoring system used in Week 7. It has tighter scoring windows than Legacy.
   * Scores the player based on judgement, represented by a step function.
   */
  var WEEK7;

  /**
   * Points Based On Timing scoring system, version 1
   * Scores the player based on the offset based on timing, represented by a sigmoid function.
   */
  var PBOT1;

  // WIFE1
  // WIFE3
}

/**
 * A static class which holds any functions related to scoring.
 */
class Scoring
{
  /**
   * Determine the score a note receives under a given scoring system.
   * @param msTiming The difference between the note's time and when it was hit.
   * @param scoringSystem The scoring system to use.
   * @return The score the note receives.
   */
  public static function scoreNote(msTiming:Float, scoringSystem:ScoringSystem = PBOT1)
  {
    switch (scoringSystem)
    {
      case LEGACY:
        return scoreNote_LEGACY(msTiming);
      case WEEK7:
        return scoreNote_WEEK7(msTiming);
      case PBOT1:
        return scoreNote_PBOT1(msTiming);
      default:
        trace('ERROR: Unknown scoring system: ' + scoringSystem);
        return 0;
    }
  }

  /**
   * Determine the judgement a note receives under a given scoring system.
   * @param msTiming The difference between the note's time and when it was hit.
   * @return The judgement the note receives.
   */
  public static function judgeNote(msTiming:Float, scoringSystem:ScoringSystem = PBOT1):String
  {
    switch (scoringSystem)
    {
      case LEGACY:
        return judgeNote_LEGACY(msTiming);
      case WEEK7:
        return judgeNote_WEEK7(msTiming);
      case PBOT1:
        return judgeNote_PBOT1(msTiming);
      default:
        trace('ERROR: Unknown scoring system: ' + scoringSystem);
        return 'miss';
    }
  }

  /**
   * The maximum score received.
   */
  public static var PBOT1_MAX_SCORE = 350;

  /**
   * The minimum score received.
   */
  public static var PBOT1_MIN_SCORE = 0;

  /**
   * The threshold at which a note hit is considered perfect and always given the max score.
  **/
  public static var PBOT1_PERFECT_THRESHOLD = 5.0; // 5ms.

  /**
   * The threshold at which a note hit is considered missed and always given the min score.
  **/
  public static var PBOT1_MISS_THRESHOLD = (10 / 60) * 1000; // ~166ms

  // Magic numbers used to tweak the shape of the scoring function.
  public static var PBOT1_SCORING_SLOPE:Float = 0.052;
  public static var PBOT1_SCORING_OFFSET:Float = 80.0;

  static function scoreNote_PBOT1(msTiming:Float):Int
  {
    // Absolute value because otherwise late hits are always given the max score.
    var absTiming = Math.abs(msTiming);
    if (absTiming > PBOT1_MISS_THRESHOLD)
    {
      return PBOT1_MIN_SCORE;
    }
    else if (absTiming < PBOT1_PERFECT_THRESHOLD)
    {
      return PBOT1_MAX_SCORE;
    }
    else
    {
      // Calculate the score based on the timing using a sigmoid function.
      var factor:Float = 1.0 - (1.0 / (1.0 + Math.exp(-PBOT1_SCORING_SLOPE * (absTiming - PBOT1_SCORING_OFFSET))));

      var score = Std.int(PBOT1_MAX_SCORE * factor);

      return score;
    }
  }

  static function judgeNote_PBOT1(msTiming:Float):String
  {
    return judgeNote_WEEK7(msTiming);
  }

  /**
   * The window of time in which a note is considered to be hit, on the Funkin Legacy scoring system.
   * Currently equal to 10 frames at 60fps, or ~166ms.
   */
  public static var LEGACY_HIT_WINDOW:Float = (10 / 60) * 1000; // 166.67 ms hit window (10 frames at 60fps)

  /**
   * The threshold at which a note is considered a "Bad" hit rather than a "Shit" hit.
   * Represented as a percentage of the total hit window.
   */
  public static var LEGACY_BAD_THRESHOLD:Float = 0.9;

  public static var LEGACY_GOOD_THRESHOLD:Float = 0.75;
  public static var LEGACY_SICK_THRESHOLD:Float = 0.2;
  public static var LEGACY_SHIT_SCORE = 50;
  public static var LEGACY_BAD_SCORE = 100;
  public static var LEGACY_GOOD_SCORE = 200;
  public static var LEGACY_SICK_SCORE = 350;

  static function scoreNote_LEGACY(msTiming:Float):Int
  {
    var absTiming = Math.abs(msTiming);
    if (absTiming < LEGACY_HIT_WINDOW * LEGACY_SICK_THRESHOLD)
    {
      return LEGACY_SICK_SCORE;
    }
    else if (absTiming < LEGACY_HIT_WINDOW * LEGACY_GOOD_THRESHOLD)
    {
      return LEGACY_GOOD_SCORE;
    }
    else if (absTiming < LEGACY_HIT_WINDOW * LEGACY_BAD_THRESHOLD)
    {
      return LEGACY_BAD_SCORE;
    }
    else if (absTiming < LEGACY_HIT_WINDOW)
    {
      return LEGACY_SHIT_SCORE;
    }
    else
    {
      return 0;
    }
  }

  static function judgeNote_LEGACY(msTiming:Float):String
  {
    var absTiming = Math.abs(msTiming);
    if (absTiming < LEGACY_HIT_WINDOW * LEGACY_SICK_THRESHOLD)
    {
      return 'sick';
    }
    else if (absTiming < LEGACY_HIT_WINDOW * LEGACY_GOOD_THRESHOLD)
    {
      return 'good';
    }
    else if (absTiming < LEGACY_HIT_WINDOW * LEGACY_BAD_THRESHOLD)
    {
      return 'bad';
    }
    else if (absTiming < LEGACY_HIT_WINDOW)
    {
      return 'shit';
    }
    else
    {
      return 'miss';
    }
  }

  /**
   * The window of time in which a note is considered to be hit, on the Funkin Classic scoring system.
   * Same as L 10 frames at 60fps, or ~166ms.
   */
  public static var WEEK7_HIT_WINDOW = LEGACY_HIT_WINDOW;

  public static var WEEK7_BAD_THRESHOLD = 0.8; // 80% of the hit window, or ~125ms
  public static var WEEK7_GOOD_THRESHOLD = 0.55; // 55% of the hit window, or ~91ms
  public static var WEEK7_SICK_THRESHOLD = 0.2; // 20% of the hit window, or ~33ms
  public static var WEEK7_SHIT_SCORE = 50;
  public static var WEEK7_BAD_SCORE = 100;
  public static var WEEK7_GOOD_SCORE = 200;
  public static var WEEK7_SICK_SCORE = 350;

  static function scoreNote_WEEK7(msTiming:Float):Int
  {
    var absTiming = Math.abs(msTiming);
    if (absTiming < WEEK7_HIT_WINDOW * WEEK7_SICK_THRESHOLD)
    {
      return WEEK7_SICK_SCORE;
    }
    else if (absTiming < WEEK7_HIT_WINDOW * WEEK7_GOOD_THRESHOLD)
    {
      return WEEK7_GOOD_SCORE;
    }
    else if (absTiming < WEEK7_HIT_WINDOW * WEEK7_BAD_THRESHOLD)
    {
      return WEEK7_BAD_SCORE;
    }
    else if (absTiming < WEEK7_HIT_WINDOW)
    {
      return WEEK7_SHIT_SCORE;
    }
    else
    {
      return 0;
    }
  }

  static function judgeNote_WEEK7(msTiming:Float):String
  {
    var absTiming = Math.abs(msTiming);
    if (absTiming < WEEK7_HIT_WINDOW * WEEK7_SICK_THRESHOLD)
    {
      return 'sick';
    }
    else if (absTiming < WEEK7_HIT_WINDOW * WEEK7_GOOD_THRESHOLD)
    {
      return 'good';
    }
    else if (absTiming < WEEK7_HIT_WINDOW * WEEK7_BAD_THRESHOLD)
    {
      return 'bad';
    }
    else if (absTiming < WEEK7_HIT_WINDOW)
    {
      return 'shit';
    }
    else
    {
      return 'miss';
    }
  }
}