Merge branch 'rewrite/master' into nothyper474/cwd-preloader

2024-11-26 17:46:08 -05:00 · 2024-06-01 16:27:08 -04:00 · 2024-06-01 16:27:08 -04:00 · c95ebaa948
commit c95ebaa948
parent ee4be81062 5fc93f1b71
70 changed files with 2955 additions and 660 deletions
--- a/.gitmodules
+++ b/.gitmodules
@ -1,6 +1,6 @@
 [submodule "assets"]
 	path = assets
-	url = https://github.com/FunkinCrew/funkin.assets
+	url = https://github.com/FunkinCrew/Funkin-Assets-secret
 [submodule "art"]
 	path = art
-	url = https://github.com/FunkinCrew/funkin.art
+	url = https://github.com/FunkinCrew/Funkin-Art-secret
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@ -3,13 +3,13 @@
  "configurations": [
    {
      // Launch in native/CPP on Windows/OSX/Linux
-      "name": "Lime",
+      "name": "Lime Build+Debug",
      "type": "lime",
      "request": "launch"
    },
    {
-      // Launch in native/CPP on Windows/OSX/Linux (without compiling)
-      "name": "Debug",
+      // Launch in native/CPP on Windows/OSX/Linux
+      "name": "Lime Debug (No Build)",
      "type": "lime",
      "request": "launch",
      "preLaunchTask": null
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@ -155,6 +155,11 @@
      "target": "hl",
      "args": ["-debug", "-DDIALOGUE"]
    },
+    {
+      "label": "Windows / Debug (Results Screen Test)",
+      "target": "windows",
+      "args": ["-debug", "-DRESULTS"]
+    },
    {
      "label": "Windows / Debug (Straight to Chart Editor)",
      "target": "windows",
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -4,11 +4,53 @@ All notable changes will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).

+## [0.4.0] - 2024-05-??
+### Added
+- 2 new Erect remixes, Eggnog and Satin Panties. Check them out from the Freeplay menu!
+- Major visual improvements to the Results screen, with additional animations and audio based on your performance.
+- Major visual improvements to the Freeplay screen, with song difficulty ratings and player rank displays.
+  - Freeplay now plays a preview of songs when you hover over them.
+- Added a Charter field to the chart format, to allow for crediting the creator of a level's chart.
+  - You can see who charted a song from the Pause menu.
+- Added a new Scroll Speed chart event to change the note speed mid-song (thanks )
+### Changed
+- Tweaked the charts for several songs:
+  - Monster
+  - Winter Horrorland
+  - Stress
+  - Lit Up
+  - Tutorial (increased the note speed slightly)
+  - Senpai (increased the note speed)
+  - Thorns (increased the note speed slightly)
+- Favorite songs marked in Freeplay are now stored between sessions.
+- Custom note styles are now properly supported for songs; add new notestyles via JSON, then select it for use from the Chart Editor Metadata toolbox. (thanks Keoiki!)
+- Improved logic for NoteHitScriptEvents, allowing you to view the hit diff and modify whether a note hit is a combo break (thanks nebulazorua!)
+- Health icons now support a Winning frame without requiring a spritesheet, simply include a third frame in the icon file. (thanks gamerbross!)
+  - Remember that for more complex behaviors such as animations or transitions, you should use an XML file to define each frame.
+### Fixed
+- Fixed a bug where the game would silently fail to load saves on HTML5
+- Fixed some bugs with the props on the Story Menu not bopping properly
+- Additional fixes to the Loading bar on HTML5 (thanks lemz1!)
+- Fixed several bugs with the TitleState, including missing music when returning from the Main Menu (thanks gamerbross!)
+- Fixed a camera bug in the Main Menu (thanks richTrash21!)
+- Fixed a bug where changing difficulties in Story mode wouldn't update the score (thanks sectorA!)
+- Fixed a crash in Freeplay caused by a level referencing an invalid song (thanks gamerbross!)
+- Fixed a bug where pressing the volume keys would stop the Toy commercial (thanks gamerbross!)
+- Fixed a bug where the Chart Editor Playtest would crash when losing (thanks gamerbross!)
+- Fixed a bug where hold notes would display improperly in the Chart Editor when downscroll was enabled for gameplay (thanks gamerbross!)
+- Fixed a bug where hold notes would be positioned wrong on downscroll (thanks MaybeMaru!)
+- Removed a large number of unused imports to optimize builds (thanks Ethan-makes-music!)
+- Improved debug logging for unscripted stages (thanks gamerbross!)
+- Made improvements to compiling documentation (thanks gedehari!)
+- Fixed a crash on Linux caused by an old version of hxCodec (thanks Noobz4Life!)
+- Optimized animation handling for characters (thanks richTrash21!)
+- Additional bug fixes and optimizations.
+
 ## [0.3.3] - 2024-05-14
 ### Changed
 - Cleaned up some code in `PlayAnimationSongEvent.hx` (thanks BurgerBalls!)
 ### Fixed
- Fix Web Loading Bar (thanks lemz1!)
+- Fixes to the Loading bar on HTML5 (thanks lemz1!)
 - Don't allow any more inputs when exiting freeplay (thanks gamerbros!)
 - Fixed using mouse wheel to scroll on freeplay (thanks JugieNoob!)
 - Fixed the reset's of the health icons, score, and notes when re-entering gameplay from gameover (thanks ImCodist!)
@ -16,11 +58,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Fixed camera stutter once a wipe transition to the Main Menu completes (thanks ImCodist!)
 - Fixed an issue where hold note would be invisible for a single frame (thanks ImCodist!)
 - Fix tween accumulation on title screen when pressing Y multiple times (thanks TheGaloXx!)
- Fix for a game over easter egg so you don't accidentally exit it when viewing
 - Fix a crash when querying FlxG.state in the crash handler
+- Fix for a game over easter egg so you don't accidentally exit it when viewing
 - Fix an issue where the Freeplay menu never displays 100% clear
+- Fix an issue where Weekend 1 Pico attempted to retrieve a missing asset.
+- Fix an issue where duplicate keybinds would be stoed, potentially causing a crash
 - Chart debug key now properly returns you to the previous chart editor session if you were playtesting a chart (thanks nebulazorua!)
- Hopefully fixed Freeplay crashes on AMD gpu's
+- Fix a crash on Freeplay found on AMD graphics cards

 ## [0.3.2] - 2024-05-03
 ### Added
--- a/Project.xml
+++ b/Project.xml
@ -1,5 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
-<project>
+<project xmlns="http://lime.openfl.org/project/1.0.4" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+xsi:schemaLocation="http://lime.openfl.org/project/1.0.4 http://lime.openfl.org/xsd/project-1.0.4.xsd">
 	<!-- _________________________ Application Settings _________________________ -->
 	<app title="Friday Night Funkin'" file="Funkin" packageName="com.funkin.fnf" package="com.funkin.fnf" main="Main" version="0.3.3" company="ninjamuffin99" />
 	<!--Switch Export with Unique ApplicationID and Icon-->
@ -28,7 +29,7 @@
 	<set name="BUILD_DIR" value="export/debug" if="debug" />
 	<set name="BUILD_DIR" value="export/release" unless="debug" />
 	<set name="BUILD_DIR" value="export/32bit" if="32bit" />
-	<classpath name="source" />
+	<source path="source" />
 	<assets path="assets/preload" rename="assets" exclude="*.ogg|*.wav" if="web" />
 	<assets path="assets/preload" rename="assets" exclude="*.mp3|*.wav" unless="web" />
 	<define name="PRELOAD_ALL" unless="web" />
@ -126,8 +127,10 @@
 	<haxelib name="hxCodec" if="desktop" unless="hl" /> <!-- Video playback -->
 	<haxelib name="funkin.vis"/>

+	<haxelib name="FlxPartialSound" /> <!-- Loading partial sound data -->

 	<haxelib name="json2object" /> <!-- JSON parsing -->
+	<haxelib name="thx.core" /> <!-- General utility library, "the lodash of Haxe" -->
 	<haxelib name="thx.semver" /> <!-- Version string handling -->

 	<haxelib name="hxcpp-debug-server" if="desktop debug" /> <!-- VSCode debug support -->
--- a/README.md
+++ b/README.md
@ -23,7 +23,7 @@ Full credits can be found in-game, or wherever the credits.json file is.

 ## Programming
 - [ninjamuffin99](https://twitter.com/ninja_muffin99) - Lead Programmer
- [MasterEric](https://twitter.com/EliteMasterEric) - Programmer
+- [EliteMasterEric](https://twitter.com/EliteMasterEric) - Programmer
 - [MtH](https://twitter.com/emmnyaa) - Charting and Additional Programming
 - [GeoKureli](https://twitter.com/Geokureli/) - Additional Programming
 - Our contributors on GitHub
--- a/2
+++ b/2
@ -1 +1 @@
-Subproject commit 66572f85d826ce2ec1d45468c12733b161237ffa
+Subproject commit faeba700c5526bd4fd57ccc927d875c82b9d3553
--- a/2
+++ b/2
@ -1 +1 @@
-Subproject commit 783f22e741c85223da7f3f815b28fc4c6f240cbc
+Subproject commit 3bfa4e3da87713ea651f60d4f898c283e5d86093
--- a/checkstyle.json
+++ b/checkstyle.json
@ -79,7 +79,7 @@
    {
      "props": {
        "ignoreExtern": true,
-        "format": "^[a-z][A-Z][A-Z0-9]*(_[A-Z0-9_]+)*$",
+        "format": "^[a-zA-Z0-9]+(?:_[a-zA-Z0-9]+)*$",
        "tokens": ["INLINE", "NOTINLINE"]
      },
      "type": "ConstantName"
--- a/example_mods/introMod/_polymod_meta.json
+++ b/example_mods/introMod/_polymod_meta.json
@ -3,7 +3,7 @@
  "description": "An introductory mod.",
  "contributors": [
    {
-      "name": "MasterEric"
+      "name": "EliteMasterEric"
    }
  ],
  "api_version": "0.1.0",
--- a/example_mods/testing123/_polymod_meta.json
+++ b/example_mods/testing123/_polymod_meta.json
@ -3,7 +3,7 @@
  "description": "Newgrounds? More like OLDGROUNDS lol.",
  "contributors": [
    {
-      "name": "MasterEric"
+      "name": "EliteMasterEric"
    }
  ],
  "api_version": "0.1.0",
--- a/hmm.json
+++ b/hmm.json
@ -1,5 +1,12 @@
 {
  "dependencies": [
+    {
+      "name": "FlxPartialSound",
+      "type": "git",
+      "dir": null,
+      "ref": "44aa7eb",
+      "url": "https://github.com/FunkinCrew/FlxPartialSound.git"
+    },
    {
      "name": "discord_rpc",
      "type": "git",
@ -153,7 +160,7 @@
      "name": "polymod",
      "type": "git",
      "dir": null,
-      "ref": "8553b800965f225bb14c7ab8f04bfa9cdec362ac",
+      "ref": "bfbe30d81601b3543d80dce580108ad6b7e182c7",
      "url": "https://github.com/larsiusprime/polymod"
    },
    {
--- a/source/funkin/InitState.hx
+++ b/source/funkin/InitState.hx
@ -214,6 +214,32 @@ class InitState extends FlxState
    #elseif STAGEBUILD
    // -DSTAGEBUILD
    FlxG.switchState(() -> new funkin.ui.debug.stage.StageBuilderState());
+    #elseif RESULTS
+    // -DRESULTS
+    FlxG.switchState(() -> new funkin.play.ResultState(
+      {
+        storyMode: false,
+        title: "Cum Song Erect by Kawai Sprite",
+        songId: "cum",
+        difficultyId: "nightmare",
+        isNewHighscore: true,
+        scoreData:
+          {
+            score: 1_234_567,
+            tallies:
+              {
+                sick: 130,
+                good: 70,
+                bad: 69,
+                shit: 69,
+                missed: 69,
+                combo: 69,
+                maxCombo: 69,
+                totalNotesHit: 140,
+                totalNotes: 200 // 0,
+              }
+          },
+      }));
    #elseif ANIMDEBUG
    // -DANIMDEBUG
    FlxG.switchState(() -> new funkin.ui.debug.anim.DebugBoundingState());
--- a/source/funkin/Paths.hx
+++ b/source/funkin/Paths.hx
@ -123,9 +123,17 @@ class Paths
    return 'songs:assets/songs/${song.toLowerCase()}/Voices$suffix.${Constants.EXT_SOUND}';
  }

-  public static function inst(song:String, ?suffix:String = ''):String
+  /**
+   * Gets the path to an `Inst.mp3/ogg` song instrumental from songs:assets/songs/`song`/
+   * @param song name of the song to get instrumental for
+   * @param suffix any suffix to add to end of song name, used for `-erect` variants usually
+   * @param withExtension if it should return with the audio file extension `.mp3` or `.ogg`.
+   * @return String
+   */
+  public static function inst(song:String, ?suffix:String = '', ?withExtension:Bool = true):String
  {
-    return 'songs:assets/songs/${song.toLowerCase()}/Inst$suffix.${Constants.EXT_SOUND}';
+    var ext:String = withExtension ? '.${Constants.EXT_SOUND}' : '';
+    return 'songs:assets/songs/${song.toLowerCase()}/Inst$suffix$ext';
  }

  public static function image(key:String, ?library:String):String
@ -153,3 +161,11 @@ class Paths
    return FlxAtlasFrames.fromSpriteSheetPacker(image(key, library), file('images/$key.txt', library));
  }
 }
+
+enum abstract PathsFunction(String)
+{
+  var MUSIC;
+  var INST;
+  var VOICES;
+  var SOUND;
+}
--- a/source/funkin/api/newgrounds/NGUnsafe.hx
+++ b/source/funkin/api/newgrounds/NGUnsafe.hx
@ -1,9 +1,5 @@
 package funkin.api.newgrounds;

-import flixel.util.FlxSignal;
-import flixel.util.FlxTimer;
-import lime.app.Application;
-import openfl.display.Stage;
 #if newgrounds
 import io.newgrounds.NG;
 import io.newgrounds.NGLite;
--- a/source/funkin/api/newgrounds/NGio.hx
+++ b/source/funkin/api/newgrounds/NGio.hx
@ -2,19 +2,11 @@ package funkin.api.newgrounds;

 #if newgrounds
 import flixel.util.FlxSignal;
-import flixel.util.FlxTimer;
 import io.newgrounds.NG;
 import io.newgrounds.NGLite;
-import io.newgrounds.components.ScoreBoardComponent.Period;
 import io.newgrounds.objects.Error;
-import io.newgrounds.objects.Medal;
 import io.newgrounds.objects.Score;
-import io.newgrounds.objects.ScoreBoard;
-import io.newgrounds.objects.events.Response;
-import io.newgrounds.objects.events.Result.GetCurrentVersionResult;
-import io.newgrounds.objects.events.Result.GetVersionResult;
 import lime.app.Application;
-import openfl.display.Stage;
 #end

 /**
--- a/source/funkin/audio/FunkinSound.hx
+++ b/source/funkin/audio/FunkinSound.hx
@ -11,10 +11,14 @@ import funkin.audio.waveform.WaveformDataParser;
 import funkin.data.song.SongData.SongMusicData;
 import funkin.data.song.SongRegistry;
 import funkin.util.tools.ICloneable;
+import funkin.util.flixel.sound.FlxPartialSound;
+import funkin.Paths.PathsFunction;
 import openfl.Assets;
+import lime.app.Future;
+import lime.app.Promise;
 import openfl.media.SoundMixer;
+
 #if (openfl >= "8.0.0")
-import openfl.utils.AssetType;
 #end

 /**
@ -342,23 +346,68 @@ class FunkinSound extends FlxSound implements ICloneable<FunkinSound>
        FlxG.log.warn('Tried and failed to find music metadata for $key');
      }
    }
-
-    var music = FunkinSound.load(Paths.music('$key/$key'), params?.startingVolume ?? 1.0, params.loop ?? true, false, true);
-    if (music != null)
+    var pathsFunction = params.pathsFunction ?? MUSIC;
+    var suffix = params.suffix ?? '';
+    var pathToUse = switch (pathsFunction)
    {
-      FlxG.sound.music = music;
+      case MUSIC: Paths.music('$key/$key');
+      case INST: Paths.inst('$key', suffix);
+      default: Paths.music('$key/$key');
+    }

-      // Prevent repeat update() and onFocus() calls.
-      FlxG.sound.list.remove(FlxG.sound.music);
+    var shouldLoadPartial = params.partialParams?.loadPartial ?? false;

-      return true;
+    if (shouldLoadPartial)
+    {
+      var music = FunkinSound.loadPartial(pathToUse, params.partialParams?.start ?? 0, params.partialParams?.end ?? 1, params?.startingVolume ?? 1.0,
+        params.loop ?? true, false, false, params.onComplete);
+
+      if (music != null)
+      {
+        while (partialQueue.length > 0)
+        {
+          @:nullSafety(Off)
+          partialQueue.pop().error("Cancel loading partial sound");
+        }
+
+        partialQueue.push(music);
+
+        @:nullSafety(Off)
+        music.future.onComplete(function(partialMusic:Null<FunkinSound>) {
+          FlxG.sound.music = partialMusic;
+          FlxG.sound.list.remove(FlxG.sound.music);
+
+          if (FlxG.sound.music != null && params.onLoad != null) params.onLoad();
+        });
+
+        return true;
+      }
+      else
+      {
+        return false;
+      }
    }
    else
    {
-      return false;
+      var music = FunkinSound.load(pathToUse, params?.startingVolume ?? 1.0, params.loop ?? true, false, true);
+      if (music != null)
+      {
+        FlxG.sound.music = music;
+
+        // Prevent repeat update() and onFocus() calls.
+        FlxG.sound.list.remove(FlxG.sound.music);
+
+        return true;
+      }
+      else
+      {
+        return false;
+      }
    }
  }

+  static var partialQueue:Array<Promise<Null<FunkinSound>>> = [];
+
  /**
   * Creates a new `FunkinSound` object synchronously.
   *
@ -415,6 +464,49 @@ class FunkinSound extends FlxSound implements ICloneable<FunkinSound>
    return sound;
  }

+  /**
+   * Will load a section of a sound file, useful for Freeplay where we don't want to load all the bytes of a song
+   * @param path The path to the sound file
+   * @param start The start time of the sound file
+   * @param end The end time of the sound file
+   * @param volume Volume to start at
+   * @param looped Whether the sound file should loop
+   * @param autoDestroy Whether the sound file should be destroyed after it finishes playing
+   * @param autoPlay Whether the sound file should play immediately
+   * @param onComplete Callback when the sound finishes playing
+   * @param onLoad Callback when the sound finishes loading
+   * @return A FunkinSound object
+   */
+  public static function loadPartial(path:String, start:Float = 0, end:Float = 1, volume:Float = 1.0, looped:Bool = false, autoDestroy:Bool = false,
+      autoPlay:Bool = true, ?onComplete:Void->Void, ?onLoad:Void->Void):Promise<Null<FunkinSound>>
+  {
+    var promise:lime.app.Promise<Null<FunkinSound>> = new lime.app.Promise<Null<FunkinSound>>();
+
+    // split the path and get only after first :
+    // we are bypassing the openfl/lime asset library fuss
+    path = Paths.stripLibrary(path);
+
+    var soundRequest = FlxPartialSound.partialLoadFromFile(path, start, end);
+
+    if (soundRequest == null)
+    {
+      promise.complete(null);
+    }
+    else
+    {
+      promise.future.onError(function(e) {
+        soundRequest.error("Sound loading was errored or cancelled");
+      });
+
+      soundRequest.future.onComplete(function(partialSound) {
+        var snd = FunkinSound.load(partialSound, volume, looped, autoDestroy, autoPlay, onComplete, onLoad);
+        promise.complete(snd);
+      });
+    }
+
+    return promise;
+  }
+
  @:nullSafety(Off)
  public override function destroy():Void
  {
@ -475,6 +567,12 @@ typedef FunkinSoundPlayMusicParams =
   */
  var ?startingVolume:Float;

+  /**
+   * The suffix of the music file to play. Usually for "-erect" tracks when loading an INST file
+   * @default ``
+   */
+  var ?suffix:String;
+
  /**
   * Whether to override music if a different track is already playing.
   * @default `false`
@ -498,4 +596,22 @@ typedef FunkinSoundPlayMusicParams =
   * @default `true`
   */
  var ?mapTimeChanges:Bool;
+
+  /**
+   * Which Paths function to use to load a song
+   * @default `MUSIC`
+   */
+  var ?pathsFunction:PathsFunction;
+
+  var ?partialParams:PartialSoundParams;
+
+  var ?onComplete:Void->Void;
+  var ?onLoad:Void->Void;
+}
+
+typedef PartialSoundParams =
+{
+  var loadPartial:Bool;
+  var start:Float;
+  var end:Float;
 }
--- a/source/funkin/audio/VoicesGroup.hx
+++ b/source/funkin/audio/VoicesGroup.hx
@ -1,9 +1,7 @@
 package funkin.audio;

-import funkin.audio.FunkinSound;
 import flixel.group.FlxGroup.FlxTypedGroup;
 import funkin.audio.waveform.WaveformData;
-import funkin.audio.waveform.WaveformDataParser;

 class VoicesGroup extends SoundGroup
 {
--- a/source/funkin/audio/visualize/ABotVis.hx
+++ b/source/funkin/audio/visualize/ABotVis.hx
@ -1,13 +1,9 @@
 package funkin.audio.visualize;

-import funkin.audio.visualize.dsp.FFT;
 import flixel.FlxSprite;
-import flixel.addons.plugin.taskManager.FlxTask;
 import flixel.graphics.frames.FlxAtlasFrames;
 import flixel.group.FlxSpriteGroup.FlxTypedSpriteGroup;
-import flixel.math.FlxMath;
 import flixel.sound.FlxSound;
-import funkin.util.MathUtil;
 import funkin.vis.dsp.SpectralAnalyzer;
 import funkin.vis.audioclip.frontends.LimeAudioClip;

--- a/source/funkin/audio/visualize/PolygonVisGroup.hx
+++ b/source/funkin/audio/visualize/PolygonVisGroup.hx
@ -1,6 +1,5 @@
 package funkin.audio.visualize;

-import funkin.audio.visualize.PolygonSpectogram;
 import flixel.group.FlxGroup.FlxTypedGroup;
 import flixel.sound.FlxSound;

--- a/source/funkin/audio/visualize/SpectogramSprite.hx
+++ b/source/funkin/audio/visualize/SpectogramSprite.hx
@ -8,8 +8,6 @@ import flixel.sound.FlxSound;
 import flixel.util.FlxColor;
 import funkin.audio.visualize.PolygonSpectogram.VISTYPE;
 import funkin.audio.visualize.VisShit.CurAudioInfo;
-import funkin.audio.visualize.dsp.FFT;
-import lime.system.ThreadPool;
 import lime.utils.Int16Array;

 using Lambda;
@ -38,8 +36,6 @@ class SpectogramSprite extends FlxTypedSpriteGroup<FlxSprite>
    lengthOfShit = amnt;

    regenLineShit();
-
-    // makeGraphic(200, 200, FlxColor.BLACK);
  }

  public function regenLineShit():Void
@ -89,8 +85,6 @@ class SpectogramSprite extends FlxTypedSpriteGroup<FlxSprite>
  {
    checkAndSetBuffer();

-    // vis.checkAndSetBuffer();
-
    if (setBuffer)
    {
      var samplesToGen:Int = Std.int(sampleRate * seconds);
@ -191,7 +185,6 @@ class SpectogramSprite extends FlxTypedSpriteGroup<FlxSprite>
          // a value between 10hz and 100Khz
          var hzPicker:Float = Math.pow(10, powedShit);

-          // var sampleApprox:Int = Std.int(FlxMath.remapToRange(i, 0, group.members.length, startingSample, startingSample + samplesToGen));
          var remappedFreq:Int = Std.int(FlxMath.remapToRange(hzPicker, 0, 10000, 0, freqShit[0].length - 1));

          group.members[i].x = prevLine.x;
@ -211,8 +204,6 @@ class SpectogramSprite extends FlxTypedSpriteGroup<FlxSprite>
          var line = FlxPoint.get(prevLine.x - group.members[i].x, prevLine.y - group.members[i].y);

          // dont draw a line until i figure out a nicer way to view da spikes and shit idk lol!
-          // group.members[i].setGraphicSize(Std.int(Math.max(line.length, 1)), Std.int(1));
-          // group.members[i].angle = line.degrees;
        }
      }
    }
@ -261,9 +252,6 @@ class SpectogramSprite extends FlxTypedSpriteGroup<FlxSprite>

          group.members[Std.int(remappedSample)].x = prevLine.x;
          group.members[Std.int(remappedSample)].y = prevLine.y;
-          // group.members[0].y = prevLine.y;
-
-          // FlxSpriteUtil.drawLine(this, prevLine.x, prevLine.y, width * remappedSample, left * height / 2 + height / 2);
          prevLine.x = (curAud.balanced * swagheight / 2 + swagheight / 2) + x;
          prevLine.y = (Std.int(remappedSample) / lengthOfShit * daHeight) + y;

--- a/source/funkin/audio/visualize/VisShit.hx
+++ b/source/funkin/audio/visualize/VisShit.hx
@ -3,7 +3,6 @@ package funkin.audio.visualize;
 import flixel.math.FlxMath;
 import flixel.sound.FlxSound;
 import funkin.audio.visualize.dsp.FFT;
-import lime.system.ThreadPool;
 import lime.utils.Int16Array;
 import funkin.util.MathUtil;

@ -73,9 +72,6 @@ class VisShit

      freqOutput.push([]);

-      // if (FlxG.keys.justPressed.M)
-      // trace(FFT.rfft(chunk).map(z -> z.scale(1 / fs).magnitude));
-
      // find spectral peaks and their instantaneous frequencies
      for (k => s in freqs)
      {
@ -91,7 +87,6 @@ class VisShit
        if (freq < maxFreq) freqOutput[indexOfArray].push(power);
        //
      }
-      // haxe.Log.trace("", null);

      indexOfArray++;
      // move to next (overlapping) chunk
--- a/source/funkin/audio/visualize/dsp/FFT.hx
+++ b/source/funkin/audio/visualize/dsp/FFT.hx
@ -1,7 +1,5 @@
 package funkin.audio.visualize.dsp;

-import funkin.audio.visualize.dsp.Complex;
-
 using funkin.audio.visualize.dsp.OffsetArray;
 using funkin.audio.visualize.dsp.Signal;

--- a/source/funkin/audio/waveform/WaveformData.hx
+++ b/source/funkin/audio/waveform/WaveformData.hx
@ -1,7 +1,5 @@
 package funkin.audio.waveform;

-import funkin.util.MathUtil;
-
@:nullSafety
 class WaveformData
 {
--- a/source/funkin/audio/waveform/WaveformSprite.hx
+++ b/source/funkin/audio/waveform/WaveformSprite.hx
@ -1,7 +1,5 @@
 package funkin.audio.waveform;

-import funkin.audio.waveform.WaveformData;
-import funkin.audio.waveform.WaveformDataParser;
 import funkin.graphics.rendering.MeshRender;
 import flixel.util.FlxColor;

--- a/source/funkin/data/dialogue/conversation/ConversationData.hx
+++ b/source/funkin/data/dialogue/conversation/ConversationData.hx
@ -1,7 +1,5 @@
 package funkin.data.dialogue.conversation;

-import funkin.data.animation.AnimationData;
-
 /**
 * A type definition for the data for a specific conversation.
 * It includes things like what dialogue boxes to use, what text to display, and what animations to play.
--- a/source/funkin/data/dialogue/conversation/ConversationRegistry.hx
+++ b/source/funkin/data/dialogue/conversation/ConversationRegistry.hx
@ -1,7 +1,6 @@
 package funkin.data.dialogue.conversation;

 import funkin.play.cutscene.dialogue.Conversation;
-import funkin.data.dialogue.conversation.ConversationData;
 import funkin.play.cutscene.dialogue.ScriptedConversation;

 class ConversationRegistry extends BaseRegistry<Conversation, ConversationData>
--- a/source/funkin/data/song/CHANGELOG.md
+++ b/source/funkin/data/song/CHANGELOG.md
@ -5,6 +5,10 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).

+## [2.2.3]
+### Added
+- Added `charter` field to denote authorship of a chart.
+
 ## [2.2.2]
 ### Added
 - Added `playData.previewStart` and `playData.previewEnd` fields to specify when in the song should the song's audio should be played as a preview in Freeplay.
--- a/source/funkin/data/song/SongData.hx
+++ b/source/funkin/data/song/SongData.hx
@ -30,6 +30,9 @@ class SongMetadata implements ICloneable<SongMetadata>
  @:default("Unknown")
  public var artist:String;

+  @:optional
+  public var charter:Null<String> = null;
+
  @:optional
  @:default(96)
  public var divisions:Null<Int>; // Optional field
@ -53,6 +56,8 @@ class SongMetadata implements ICloneable<SongMetadata>
  @:default(funkin.data.song.SongRegistry.DEFAULT_GENERATEDBY)
  public var generatedBy:String;

+  @:optional
+  @:default(funkin.data.song.SongData.SongTimeFormat.MILLISECONDS)
  public var timeFormat:SongTimeFormat;

  public var timeChanges:Array<SongTimeChange>;
@ -112,14 +117,23 @@ class SongMetadata implements ICloneable<SongMetadata>
   */
  public function serialize(pretty:Bool = true):String
  {
+    // Update generatedBy and version before writing.
+    updateVersionToLatest();
+
    var ignoreNullOptionals = true;
    var writer = new json2object.JsonWriter<SongMetadata>(ignoreNullOptionals);
-    // I believe @:jignored should be iggnored by the writer?
+    // I believe @:jignored should be ignored by the writer?
    // var output = this.clone();
    // output.variation = null; // Not sure how to make a field optional on the reader and ignored on the writer.
    return writer.write(this, pretty ? '  ' : null);
  }

+  public function updateVersionToLatest():Void
+  {
+    this.version = SongRegistry.SONG_METADATA_VERSION;
+    this.generatedBy = SongRegistry.DEFAULT_GENERATEDBY;
+  }
+
  /**
   * Produces a string representation suitable for debugging.
   */
@ -368,6 +382,12 @@ class SongMusicData implements ICloneable<SongMusicData>
    this.variation = variation == null ? Constants.DEFAULT_VARIATION : variation;
  }

+  public function updateVersionToLatest():Void
+  {
+    this.version = SongRegistry.SONG_MUSIC_DATA_VERSION;
+    this.generatedBy = SongRegistry.DEFAULT_GENERATEDBY;
+  }
+
  public function clone():SongMusicData
  {
    var result:SongMusicData = new SongMusicData(this.songName, this.artist, this.variation);
@ -600,11 +620,20 @@ class SongChartData implements ICloneable<SongChartData>
   */
  public function serialize(pretty:Bool = true):String
  {
+    // Update generatedBy and version before writing.
+    updateVersionToLatest();
+
    var ignoreNullOptionals = true;
    var writer = new json2object.JsonWriter<SongChartData>(ignoreNullOptionals);
    return writer.write(this, pretty ? '  ' : null);
  }

+  public function updateVersionToLatest():Void
+  {
+    this.version = SongRegistry.SONG_CHART_DATA_VERSION;
+    this.generatedBy = SongRegistry.DEFAULT_GENERATEDBY;
+  }
+
  public function clone():SongChartData
  {
    // We have to manually perform the deep clone here because Map.deepClone() doesn't work.
--- a/source/funkin/data/song/SongRegistry.hx
+++ b/source/funkin/data/song/SongRegistry.hx
@ -20,7 +20,7 @@ class SongRegistry extends BaseRegistry<Song, SongMetadata>
   * Handle breaking changes by incrementing this value
   * and adding migration to the `migrateStageData()` function.
   */
-  public static final SONG_METADATA_VERSION:thx.semver.Version = "2.2.2";
+  public static final SONG_METADATA_VERSION:thx.semver.Version = "2.2.3";

  public static final SONG_METADATA_VERSION_RULE:thx.semver.VersionRule = "2.2.x";

--- a/source/funkin/data/song/importer/ChartManifestData.hx
+++ b/source/funkin/data/song/importer/ChartManifestData.hx
@ -61,10 +61,18 @@ class ChartManifestData
   */
  public function serialize(pretty:Bool = true):String
  {
+    // Update generatedBy and version before writing.
+    updateVersionToLatest();
+
    var writer = new json2object.JsonWriter<ChartManifestData>();
    return writer.write(this, pretty ? '  ' : null);
  }

+  public function updateVersionToLatest():Void
+  {
+    this.version = CHART_MANIFEST_DATA_VERSION;
+  }
+
  public static function deserialize(contents:String):Null<ChartManifestData>
  {
    var parser = new json2object.JsonParser<ChartManifestData>();
--- a/source/funkin/data/song/importer/FNFLegacyImporter.hx
+++ b/source/funkin/data/song/importer/FNFLegacyImporter.hx
@ -36,7 +36,7 @@ class FNFLegacyImporter
  {
    trace('Migrating song metadata from FNF Legacy.');

-    var songMetadata:SongMetadata = new SongMetadata('Import', 'Kawai Sprite', 'default');
+    var songMetadata:SongMetadata = new SongMetadata('Import', Constants.DEFAULT_ARTIST, 'default');

    var hadError:Bool = false;

--- a/source/funkin/data/stage/StageData.hx
+++ b/source/funkin/data/stage/StageData.hx
@ -58,9 +58,17 @@ class StageData
   */
  public function serialize(pretty:Bool = true):String
  {
+    // Update generatedBy and version before writing.
+    updateVersionToLatest();
+
    var writer = new json2object.JsonWriter<StageData>();
    return writer.write(this, pretty ? '  ' : null);
  }
+
+  public function updateVersionToLatest():Void
+  {
+    this.version = StageRegistry.STAGE_DATA_VERSION;
+  }
 }

 typedef StageDataCharacters =
--- a/source/funkin/effects/IntervalShake.hx
+++ b/source/funkin/effects/IntervalShake.hx
@ -0,0 +1,240 @@
+package funkin.effects;
+
+import flixel.FlxObject;
+import flixel.util.FlxDestroyUtil.IFlxDestroyable;
+import flixel.util.FlxPool;
+import flixel.util.FlxTimer;
+import flixel.math.FlxPoint;
+import flixel.util.FlxAxes;
+import flixel.tweens.FlxEase.EaseFunction;
+import flixel.math.FlxMath;
+
+/**
+ * pretty much a copy of FlxFlicker geared towards making sprites
+ * shake around at a set interval and slow down over time.
+ */
+class IntervalShake implements IFlxDestroyable
+{
+  static var _pool:FlxPool<IntervalShake> = new FlxPool<IntervalShake>(IntervalShake.new);
+
+  /**
+   * Internal map for looking up which objects are currently shaking and getting their shake data.
+   */
+  static var _boundObjects:Map<FlxObject, IntervalShake> = new Map<FlxObject, IntervalShake>();
+
+  /**
+   * An effect that shakes the sprite on a set interval and a starting intensity that goes down over time.
+   *
+   * @param   Object               The object to shake.
+   * @param   Duration             How long to shake for (in seconds). `0` means "forever".
+   * @param   Interval             In what interval to update the shake position. Set to `FlxG.elapsed` if `<= 0`!
+   * @param   StartIntensity       The starting intensity of the shake.
+   * @param   EndIntensity         The ending intensity of the shake.
+   * @param   Ease                 Control the easing of the intensity over the shake.
+   * @param   CompletionCallback   Callback on shake completion
+   * @param   ProgressCallback     Callback on each shake interval
+   * @return The `IntervalShake` object. `IntervalShake`s are pooled internally, so beware of storing references.
+   */
+  public static function shake(Object:FlxObject, Duration:Float = 1, Interval:Float = 0.04, StartIntensity:Float = 0, EndIntensity:Float = 0,
+      Ease:EaseFunction, ?CompletionCallback:IntervalShake->Void, ?ProgressCallback:IntervalShake->Void):IntervalShake
+  {
+    if (isShaking(Object))
+    {
+      // if (ForceRestart)
+      // {
+      //   stopShaking(Object);
+      // }
+      // else
+      // {
+      // Ignore this call if object is already flickering.
+      return _boundObjects[Object];
+      // }
+    }
+
+    if (Interval <= 0)
+    {
+      Interval = FlxG.elapsed;
+    }
+
+    var shake:IntervalShake = _pool.get();
+    shake.start(Object, Duration, Interval, StartIntensity, EndIntensity, Ease, CompletionCallback, ProgressCallback);
+    return _boundObjects[Object] = shake;
+  }
+
+  /**
+   * Returns whether the object is shaking or not.
+   *
+   * @param   Object The object to test.
+   */
+  public static function isShaking(Object:FlxObject):Bool
+  {
+    return _boundObjects.exists(Object);
+  }
+
+  /**
+   * Stops shaking the object.
+   *
+   * @param   Object The object to stop shaking.
+   */
+  public static function stopShaking(Object:FlxObject):Void
+  {
+    var boundShake:IntervalShake = _boundObjects[Object];
+    if (boundShake != null)
+    {
+      boundShake.stop();
+    }
+  }
+
+  /**
+   * The shaking object.
+   */
+  public var object(default, null):FlxObject;
+
+  /**
+   * The shaking timer. You can check how many seconds has passed since shaking started etc.
+   */
+  public var timer(default, null):FlxTimer;
+
+  /**
+   * The starting intensity of the shake.
+   */
+  public var startIntensity(default, null):Float;
+
+  /**
+   * The ending intensity of the shake.
+   */
+  public var endIntensity(default, null):Float;
+
+  /**
+   * How long to shake for (in seconds). `0` means "forever".
+   */
+  public var duration(default, null):Float;
+
+  /**
+   * The interval of the shake.
+   */
+  public var interval(default, null):Float;
+
+  /**
+   * Defines on what axes to `shake()`. Default value is `XY` / both.
+   */
+  public var axes(default, null):FlxAxes;
+
+  /**
+   * Defines the initial position of the object at the beginning of the shake effect.
+   */
+  public var initialOffset(default, null):FlxPoint;
+
+  /**
+   * The callback that will be triggered after the shake has completed.
+   */
+  public var completionCallback(default, null):IntervalShake->Void;
+
+  /**
+   * The callback that will be triggered every time the object shakes.
+   */
+  public var progressCallback(default, null):IntervalShake->Void;
+
+  /**
+   * The easing of the intensity over the shake.
+   */
+  public var ease(default, null):EaseFunction;
+
+  /**
+   * Nullifies the references to prepare object for reuse and avoid memory leaks.
+   */
+  public function destroy():Void
+  {
+    object = null;
+    timer = null;
+    ease = null;
+    completionCallback = null;
+    progressCallback = null;
+  }
+
+  /**
+   * Starts shaking behavior.
+   */
+  function start(Object:FlxObject, Duration:Float = 1, Interval:Float = 0.04, StartIntensity:Float = 0, EndIntensity:Float = 0, Ease:EaseFunction,
+      ?CompletionCallback:IntervalShake->Void, ?ProgressCallback:IntervalShake->Void):Void
+  {
+    object = Object;
+    duration = Duration;
+    interval = Interval;
+    completionCallback = CompletionCallback;
+    startIntensity = StartIntensity;
+    endIntensity = EndIntensity;
+    initialOffset = new FlxPoint(Object.x, Object.y);
+    ease = Ease;
+    axes = FlxAxes.XY;
+    _secondsSinceStart = 0;
+    timer = new FlxTimer().start(interval, shakeProgress, Std.int(duration / interval));
+  }
+
+  /**
+   * Prematurely ends shaking.
+   */
+  public function stop():Void
+  {
+    timer.cancel();
+    // object.visible = true;
+    object.x = initialOffset.x;
+    object.y = initialOffset.y;
+    release();
+  }
+
+  /**
+   * Unbinds the object from shaking and releases it into pool for reuse.
+   */
+  function release():Void
+  {
+    _boundObjects.remove(object);
+    _pool.put(this);
+  }
+
+  public var _secondsSinceStart(default, null):Float = 0;
+
+  public var scale(default, null):Float = 0;
+
+  /**
+   * Just a helper function for shake() to update object's position.
+   */
+  function shakeProgress(timer:FlxTimer):Void
+  {
+    _secondsSinceStart += interval;
+    scale = _secondsSinceStart / duration;
+    if (ease != null)
+    {
+      scale = 1 - ease(scale);
+      // trace(scale);
+    }
+
+    var curIntensity:Float = 0;
+    curIntensity = FlxMath.lerp(endIntensity, startIntensity, scale);
+
+    if (axes.x) object.x = initialOffset.x + FlxG.random.float((-curIntensity) * object.width, (curIntensity) * object.width);
+    if (axes.y) object.y = initialOffset.y + FlxG.random.float((-curIntensity) * object.width, (curIntensity) * object.width);
+
+    // object.visible = !object.visible;
+
+    if (progressCallback != null) progressCallback(this);
+
+    if (timer.loops > 0 && timer.loopsLeft == 0)
+    {
+      object.x = initialOffset.x;
+      object.y = initialOffset.y;
+      if (completionCallback != null)
+      {
+        completionCallback(this);
+      }
+
+      if (this.timer == timer) release();
+    }
+  }
+
+  /**
+   * Internal constructor. Use static methods.
+   */
+  @:keep
+  function new() {}
+}
--- a/source/funkin/import.hx
+++ b/source/funkin/import.hx
@ -11,6 +11,7 @@ import flixel.system.debug.watch.Tracker;
 // These are great.
 using Lambda;
 using StringTools;
+using thx.Arrays;
 using funkin.util.tools.ArraySortTools;
 using funkin.util.tools.ArrayTools;
 using funkin.util.tools.FloatTools;
--- a/source/funkin/input/Controls.hx
+++ b/source/funkin/input/Controls.hx
@ -715,7 +715,7 @@ class Controls extends FlxActionSet
          case Control.VOLUME_UP: return [PLUS, NUMPADPLUS];
          case Control.VOLUME_DOWN: return [MINUS, NUMPADMINUS];
          case Control.VOLUME_MUTE: return [ZERO, NUMPADZERO];
-          case Control.FULLSCREEN: return [FlxKey.F];
+          case Control.FULLSCREEN: return [FlxKey.F11]; // We use F for other things LOL.

        }
      case Duo(true):
@ -997,7 +997,7 @@ class Controls extends FlxActionSet
    for (control in Control.createAll())
    {
      var inputs:Array<Int> = Reflect.field(data, control.getName());
-      inputs = inputs.unique();
+      inputs = inputs.distinct();
      if (inputs != null)
      {
        if (inputs.length == 0) {
@ -1050,7 +1050,7 @@ class Controls extends FlxActionSet
      if (inputs.length == 0) {
        inputs = [FlxKey.NONE];
      } else {
-        inputs = inputs.unique();
+        inputs = inputs.distinct();
      }

      Reflect.setField(data, control.getName(), inputs);
--- a/source/funkin/play/PauseSubState.hx
+++ b/source/funkin/play/PauseSubState.hx
@ -101,6 +101,10 @@ class PauseSubState extends MusicBeatSubState
   */
  static final MUSIC_FINAL_VOLUME:Float = 0.75;

+  static final CHARTER_FADE_DELAY:Float = 15.0;
+
+  static final CHARTER_FADE_DURATION:Float = 0.75;
+
  /**
   * Defines which pause music to use.
   */
@ -163,6 +167,12 @@ class PauseSubState extends MusicBeatSubState
   */
  var metadataDeaths:FlxText;

+  /**
+   * A text object which displays the current song's artist.
+   * Fades to the charter after a period before fading back.
+   */
+  var metadataArtist:FlxText;
+
  /**
   * The actual text objects for the menu entries.
   */
@ -203,6 +213,8 @@ class PauseSubState extends MusicBeatSubState
    regenerateMenu();

    transitionIn();
+
+    startCharterTimer();
  }

  /**
@ -222,6 +234,8 @@ class PauseSubState extends MusicBeatSubState
  public override function destroy():Void
  {
    super.destroy();
+    charterFadeTween.cancel();
+    charterFadeTween = null;
    pauseMusic.stop();
  }

@ -270,16 +284,25 @@ class PauseSubState extends MusicBeatSubState
    metadata.scrollFactor.set(0, 0);
    add(metadata);

-    var metadataSong:FlxText = new FlxText(20, 15, FlxG.width - 40, 'Song Name - Artist');
+    var metadataSong:FlxText = new FlxText(20, 15, FlxG.width - 40, 'Song Name');
    metadataSong.setFormat(Paths.font('vcr.ttf'), 32, FlxColor.WHITE, FlxTextAlign.RIGHT);
    if (PlayState.instance?.currentChart != null)
    {
-      metadataSong.text = '${PlayState.instance.currentChart.songName} - ${PlayState.instance.currentChart.songArtist}';
+      metadataSong.text = '${PlayState.instance.currentChart.songName}';
    }
    metadataSong.scrollFactor.set(0, 0);
    metadata.add(metadataSong);

-    var metadataDifficulty:FlxText = new FlxText(20, 15 + 32, FlxG.width - 40, 'Difficulty: ');
+    metadataArtist = new FlxText(20, metadataSong.y + 32, FlxG.width - 40, 'Artist: ${Constants.DEFAULT_ARTIST}');
+    metadataArtist.setFormat(Paths.font('vcr.ttf'), 32, FlxColor.WHITE, FlxTextAlign.RIGHT);
+    if (PlayState.instance?.currentChart != null)
+    {
+      metadataArtist.text = 'Artist: ${PlayState.instance.currentChart.songArtist}';
+    }
+    metadataArtist.scrollFactor.set(0, 0);
+    metadata.add(metadataArtist);
+
+    var metadataDifficulty:FlxText = new FlxText(20, metadataArtist.y + 32, FlxG.width - 40, 'Difficulty: ');
    metadataDifficulty.setFormat(Paths.font('vcr.ttf'), 32, FlxColor.WHITE, FlxTextAlign.RIGHT);
    if (PlayState.instance?.currentDifficulty != null)
    {
@ -288,12 +311,12 @@ class PauseSubState extends MusicBeatSubState
    metadataDifficulty.scrollFactor.set(0, 0);
    metadata.add(metadataDifficulty);

-    metadataDeaths = new FlxText(20, 15 + 64, FlxG.width - 40, '${PlayState.instance?.deathCounter} Blue Balls');
+    metadataDeaths = new FlxText(20, metadataDifficulty.y + 32, FlxG.width - 40, '${PlayState.instance?.deathCounter} Blue Balls');
    metadataDeaths.setFormat(Paths.font('vcr.ttf'), 32, FlxColor.WHITE, FlxTextAlign.RIGHT);
    metadataDeaths.scrollFactor.set(0, 0);
    metadata.add(metadataDeaths);

-    metadataPractice = new FlxText(20, 15 + 96, FlxG.width - 40, 'PRACTICE MODE');
+    metadataPractice = new FlxText(20, metadataDeaths.y + 32, FlxG.width - 40, 'PRACTICE MODE');
    metadataPractice.setFormat(Paths.font('vcr.ttf'), 32, FlxColor.WHITE, FlxTextAlign.RIGHT);
    metadataPractice.visible = PlayState.instance?.isPracticeMode ?? false;
    metadataPractice.scrollFactor.set(0, 0);
@ -302,6 +325,62 @@ class PauseSubState extends MusicBeatSubState
    updateMetadataText();
  }

+  var charterFadeTween:Null<FlxTween> = null;
+
+  function startCharterTimer():Void
+  {
+    charterFadeTween = FlxTween.tween(metadataArtist, {alpha: 0.0}, CHARTER_FADE_DURATION,
+      {
+        startDelay: CHARTER_FADE_DELAY,
+        ease: FlxEase.quartOut,
+        onComplete: (_) -> {
+          if (PlayState.instance?.currentChart != null)
+          {
+            metadataArtist.text = 'Charter: ${PlayState.instance.currentChart.charter ?? 'Unknown'}';
+          }
+          else
+          {
+            metadataArtist.text = 'Charter: ${Constants.DEFAULT_CHARTER}';
+          }
+
+          FlxTween.tween(metadataArtist, {alpha: 1.0}, CHARTER_FADE_DURATION,
+            {
+              ease: FlxEase.quartOut,
+              onComplete: (_) -> {
+                startArtistTimer();
+              }
+            });
+        }
+      });
+  }
+
+  function startArtistTimer():Void
+  {
+    charterFadeTween = FlxTween.tween(metadataArtist, {alpha: 0.0}, CHARTER_FADE_DURATION,
+      {
+        startDelay: CHARTER_FADE_DELAY,
+        ease: FlxEase.quartOut,
+        onComplete: (_) -> {
+          if (PlayState.instance?.currentChart != null)
+          {
+            metadataArtist.text = 'Artist: ${PlayState.instance.currentChart.songArtist}';
+          }
+          else
+          {
+            metadataArtist.text = 'Artist: ${Constants.DEFAULT_ARTIST}';
+          }
+
+          FlxTween.tween(metadataArtist, {alpha: 1.0}, CHARTER_FADE_DURATION,
+            {
+              ease: FlxEase.quartOut,
+              onComplete: (_) -> {
+                startCharterTimer();
+              }
+            });
+        }
+      });
+  }
+
  /**
   * Perform additional animations to transition the pause menu in when it is first displayed.
   */
--- a/source/funkin/play/PlayState.hx
+++ b/source/funkin/play/PlayState.hx
@ -2317,8 +2317,6 @@ class PlayState extends MusicBeatSubState
    var notesInRange:Array<NoteSprite> = playerStrumline.getNotesMayHit();
    var holdNotesInRange:Array<SustainTrail> = playerStrumline.getHoldNotesHitOrMissed();

-    // If there are notes in range, pressing a key will cause a ghost miss.
-
    var notesByDirection:Array<Array<NoteSprite>> = [[], [], [], []];

    for (note in notesInRange)
@ -2340,17 +2338,27 @@ class PlayState extends MusicBeatSubState

        // Play the strumline animation.
        playerStrumline.playPress(input.noteDirection);
+        trace('PENALTY Score: ${songScore}');
      }
-      else if (Constants.GHOST_TAPPING && (holdNotesInRange.length + notesInRange.length > 0) && notesInDirection.length == 0)
+      else if (Constants.GHOST_TAPPING && (!playerStrumline.mayGhostTap()) && notesInDirection.length == 0)
      {
-        // Pressed a wrong key with no notes nearby AND with notes in a different direction available.
+        // Pressed a wrong key with notes visible on-screen.
        // Perform a ghost miss (anti-spam).
        ghostNoteMiss(input.noteDirection, notesInRange.length > 0);

        // Play the strumline animation.
        playerStrumline.playPress(input.noteDirection);
+        trace('PENALTY Score: ${songScore}');
      }
-      else if (notesInDirection.length > 0)
+      else if (notesInDirection.length == 0)
+      {
+        // Press a key with no penalty.
+
+        // Play the strumline animation.
+        playerStrumline.playPress(input.noteDirection);
+        trace('NO PENALTY Score: ${songScore}');
+      }
+      else
      {
        // Choose the first note, deprioritizing low priority notes.
        var targetNote:Null<NoteSprite> = notesInDirection.find((note) -> !note.lowPriority);
@ -2360,17 +2368,13 @@ class PlayState extends MusicBeatSubState
        // Judge and hit the note.
        trace('Hit note! ${targetNote.noteData}');
        goodNoteHit(targetNote, input);
+        trace('Score: ${songScore}');

        notesInDirection.remove(targetNote);

        // Play the strumline animation.
        playerStrumline.playConfirm(input.noteDirection);
      }
-      else
-      {
-        // Play the strumline animation.
-        playerStrumline.playPress(input.noteDirection);
-      }
    }

    while (inputReleaseQueue.length > 0)
@ -2804,6 +2808,7 @@ class PlayState extends MusicBeatSubState
    deathCounter = 0;

    var isNewHighscore = false;
+    var prevScoreData:Null<SaveScoreData> = Save.instance.getSongScore(currentSong.id, currentDifficulty);

    if (currentSong != null && currentSong.validScore)
    {
@ -2823,7 +2828,6 @@ class PlayState extends MusicBeatSubState
              totalNotesHit: Highscore.tallies.totalNotesHit,
              totalNotes: Highscore.tallies.totalNotes,
            },
-          accuracy: Highscore.tallies.totalNotesHit / Highscore.tallies.totalNotes,
        };

      // adds current song data into the tallies for the level (story levels)
@ -2860,7 +2864,7 @@ class PlayState extends MusicBeatSubState
              score: PlayStatePlaylist.campaignScore,
              tallies:
                {
-                  // TODO: Sum up the values for the whole level!
+                  // TODO: Sum up the values for the whole week!
                  sick: 0,
                  good: 0,
                  bad: 0,
@ -2871,7 +2875,6 @@ class PlayState extends MusicBeatSubState
                  totalNotesHit: 0,
                  totalNotes: 0,
                },
-              accuracy: Highscore.tallies.totalNotesHit / Highscore.tallies.totalNotes,
            };

          if (Save.instance.isLevelHighScore(PlayStatePlaylist.campaignId, PlayStatePlaylist.campaignDifficulty, data))
@ -2957,11 +2960,11 @@ class PlayState extends MusicBeatSubState
      {
        if (rightGoddamnNow)
        {
-          moveToResultsScreen(isNewHighscore);
+          moveToResultsScreen(isNewHighscore, prevScoreData);
        }
        else
        {
-          zoomIntoResultsScreen(isNewHighscore);
+          zoomIntoResultsScreen(isNewHighscore, prevScoreData);
        }
      }
    }
@ -3035,7 +3038,7 @@ class PlayState extends MusicBeatSubState
  /**
   * Play the camera zoom animation and then move to the results screen once it's done.
   */
-  function zoomIntoResultsScreen(isNewHighscore:Bool):Void
+  function zoomIntoResultsScreen(isNewHighscore:Bool, ?prevScoreData:SaveScoreData):Void
  {
    trace('WENT TO RESULTS SCREEN!');

@ -3075,7 +3078,7 @@ class PlayState extends MusicBeatSubState
    FlxTween.tween(camHUD, {alpha: 0}, 0.6,
      {
        onComplete: function(_) {
-          moveToResultsScreen(isNewHighscore);
+          moveToResultsScreen(isNewHighscore, prevScoreData);
        }
      });

@ -3108,7 +3111,7 @@ class PlayState extends MusicBeatSubState
  /**
   * Move to the results screen right goddamn now.
   */
-  function moveToResultsScreen(isNewHighscore:Bool):Void
+  function moveToResultsScreen(isNewHighscore:Bool, ?prevScoreData:SaveScoreData):Void
  {
    persistentUpdate = false;
    vocals.stop();
@ -3119,7 +3122,10 @@ class PlayState extends MusicBeatSubState
    var res:ResultState = new ResultState(
      {
        storyMode: PlayStatePlaylist.isStoryMode,
+        songId: currentChart.song.id,
+        difficultyId: currentDifficulty,
        title: PlayStatePlaylist.isStoryMode ? ('${PlayStatePlaylist.campaignTitle}') : ('${currentChart.songName} by ${currentChart.songArtist}'),
+        prevScoreData: prevScoreData,
        scoreData:
          {
            score: PlayStatePlaylist.isStoryMode ? PlayStatePlaylist.campaignScore : songScore,
@ -3135,7 +3141,6 @@ class PlayState extends MusicBeatSubState
                totalNotesHit: talliesToUse.totalNotesHit,
                totalNotes: talliesToUse.totalNotes,
              },
-            accuracy: Highscore.tallies.totalNotesHit / Highscore.tallies.totalNotes,
          },
        isNewHighscore: isNewHighscore
      });
--- a/source/funkin/play/ResultState.hx
+++ b/source/funkin/play/ResultState.hx
@ -12,163 +12,235 @@ import funkin.ui.MusicBeatSubState;
 import flixel.math.FlxRect;
 import flixel.text.FlxBitmapText;
 import funkin.ui.freeplay.FreeplayScore;
+import flixel.text.FlxText;
+import flixel.util.FlxColor;
 import flixel.tweens.FlxEase;
+import funkin.graphics.FunkinCamera;
 import funkin.ui.freeplay.FreeplayState;
 import flixel.tweens.FlxTween;
+import flixel.addons.display.FlxBackdrop;
 import funkin.audio.FunkinSound;
 import flixel.util.FlxGradient;
 import flixel.util.FlxTimer;
 import funkin.save.Save;
+import funkin.play.scoring.Scoring;
 import funkin.save.Save.SaveScoreData;
 import funkin.graphics.shaders.LeftMaskShader;
 import funkin.play.components.TallyCounter;
+import funkin.play.components.ClearPercentCounter;

 /**
 * The state for the results screen after a song or week is finished.
 */
+@:nullSafety
 class ResultState extends MusicBeatSubState
 {
  final params:ResultsStateParams;

-  var resultsVariation:ResultVariations;
-  var songName:FlxBitmapText;
-  var difficulty:FlxSprite;
+  final rank:ScoringRank;
+  final songName:FlxBitmapText;
+  final difficulty:FlxSprite;
+  final clearPercentSmall:ClearPercentCounter;

-  var maskShaderSongName:LeftMaskShader = new LeftMaskShader();
-  var maskShaderDifficulty:LeftMaskShader = new LeftMaskShader();
+  final maskShaderSongName:LeftMaskShader = new LeftMaskShader();
+  final maskShaderDifficulty:LeftMaskShader = new LeftMaskShader();
+
+  final resultsAnim:FunkinSprite;
+  final ratingsPopin:FunkinSprite;
+  final scorePopin:FunkinSprite;
+
+  final bgFlash:FlxSprite;
+
+  final highscoreNew:FlxSprite;
+  final score:ResultScore;
+
+  var bfPerfect:Null<FlxAtlasSprite> = null;
+  var bfExcellent:Null<FlxAtlasSprite> = null;
+  var bfGreat:Null<FlxAtlasSprite> = null;
+  var bfGood:Null<FlxSprite> = null;
+  var gfGood:Null<FlxSprite> = null;
+  var bfShit:Null<FlxAtlasSprite> = null;
+
+  final cameraBG:FunkinCamera;
+  final cameraScroll:FunkinCamera;
+  final cameraEverything:FunkinCamera;

  public function new(params:ResultsStateParams)
  {
    super();

    this.params = params;
-  }

-  override function create():Void
-  {
-    /*
-      if (params.scoreData.sick == params.scoreData.totalNotesHit
-        && params.scoreData.maxCombo == params.scoreData.totalNotesHit) resultsVariation = PERFECT;
-      else if (params.scoreData.missed + params.scoreData.bad + params.scoreData.shit >= params.scoreData.totalNotes * 0.50)
-        resultsVariation = SHIT; // if more than half of your song was missed, bad, or shit notes, you get shit ending!
-      else
-        resultsVariation = NORMAL;
-     */
-    resultsVariation = NORMAL;
+    rank = Scoring.calculateRank(params.scoreData) ?? SHIT;

-    FunkinSound.playMusic('results$resultsVariation',
-      {
-        startingVolume: 1.0,
-        overrideExisting: true,
-        restartTrack: true,
-        loop: resultsVariation != SHIT
-      });
+    cameraBG = new FunkinCamera('resultsBG', 0, 0, FlxG.width, FlxG.height);
+    cameraScroll = new FunkinCamera('resultsScroll', 0, 0, FlxG.width, FlxG.height);
+    cameraEverything = new FunkinCamera('resultsEverything', 0, 0, FlxG.width, FlxG.height);

-    // Reset the camera zoom on the results screen.
-    FlxG.camera.zoom = 1.0;
-
-    // TEMP-ish, just used to sorta "cache" the 3000x3000 image!
-    var cacheBullShit:FlxSprite = new FlxSprite().loadGraphic(Paths.image("resultScreen/soundSystem"));
-    add(cacheBullShit);
-
-    var dumb:FlxSprite = new FlxSprite().loadGraphic(Paths.image("resultScreen/scorePopin"));
-    add(dumb);
-
-    var bg:FlxSprite = FlxGradient.createGradientFlxSprite(FlxG.width, FlxG.height, [0xFFFECC5C, 0xFFFDC05C], 90);
-    bg.scrollFactor.set();
-    add(bg);
-
-    var bgFlash:FlxSprite = FlxGradient.createGradientFlxSprite(FlxG.width, FlxG.height, [0xFFFFEB69, 0xFFFFE66A], 90);
-    bgFlash.scrollFactor.set();
-    bgFlash.visible = false;
-    add(bgFlash);
-
-    // var bfGfExcellent:FlxAtlasSprite = new FlxAtlasSprite(380, -170, Paths.animateAtlas("resultScreen/resultsBoyfriendExcellent", "shared"));
-    // bfGfExcellent.visible = false;
-    // add(bfGfExcellent);
-    //
-    // var bfPerfect:FlxAtlasSprite = new FlxAtlasSprite(370, -180, Paths.animateAtlas("resultScreen/resultsBoyfriendPerfect", "shared"));
-    // bfPerfect.visible = false;
-    // add(bfPerfect);
-    //
-    // var bfSHIT:FlxAtlasSprite = new FlxAtlasSprite(0, 20, Paths.animateAtlas("resultScreen/resultsBoyfriendSHIT", "shared"));
-    // bfSHIT.visible = false;
-    // add(bfSHIT);
-    //
-    // bfGfExcellent.anim.onComplete = () -> {
-    // bfGfExcellent.anim.curFrame = 28;
-    // bfGfExcellent.anim.play(); // unpauses this anim, since it's on PlayOnce!
-    // };
-    //
-    // bfPerfect.anim.onComplete = () -> {
-    //  bfPerfect.anim.curFrame = 136;
-    //  bfPerfect.anim.play(); // unpauses this anim, since it's on PlayOnce!
-    // };
-    //
-    // bfSHIT.anim.onComplete = () -> {
-    //  bfSHIT.anim.curFrame = 150;
-    //  bfSHIT.anim.play(); // unpauses this anim, since it's on PlayOnce!
-    // };
-
-    var gf:FlxSprite = FunkinSprite.createSparrow(625, 325, 'resultScreen/resultGirlfriendGOOD');
-    gf.animation.addByPrefix("clap", "Girlfriend Good Anim", 24, false);
-    gf.visible = false;
-    gf.animation.finishCallback = _ -> {
-      gf.animation.play('clap', true, false, 9);
-    };
-    add(gf);
-
-    var boyfriend:FlxSprite = FunkinSprite.createSparrow(640, -200, 'resultScreen/resultBoyfriendGOOD');
-    boyfriend.animation.addByPrefix("fall", "Boyfriend Good Anim0", 24, false);
-    boyfriend.visible = false;
-    boyfriend.animation.finishCallback = function(_) {
-      boyfriend.animation.play('fall', true, false, 14);
-    };
-
-    add(boyfriend);
-
-    var soundSystem:FlxSprite = FunkinSprite.createSparrow(-15, -180, 'resultScreen/soundSystem');
-    soundSystem.animation.addByPrefix("idle", "sound system", 24, false);
-    soundSystem.visible = false;
-    new FlxTimer().start(0.4, _ -> {
-      soundSystem.animation.play("idle");
-      soundSystem.visible = true;
-    });
-    add(soundSystem);
-
-    difficulty = new FlxSprite(555);
-
-    var diffSpr:String = switch (PlayState.instance.currentDifficulty)
-    {
-      case 'easy':
-        'difEasy';
-      case 'normal':
-        'difNormal';
-      case 'hard':
-        'difHard';
-      case 'erect':
-        'difErect';
-      case 'nightmare':
-        'difNightmare';
-      case _:
-        'difNormal';
-    }
-
-    difficulty.loadGraphic(Paths.image("resultScreen/" + diffSpr));
-    add(difficulty);
+    // We build a lot of this stuff in the constructor, then place it in create().
+    // This prevents having to do `null` checks everywhere.

    var fontLetters:String = "AaBbCcDdEeFfGgHhiIJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz:1234567890";
    songName = new FlxBitmapText(FlxBitmapFont.fromMonospace(Paths.image("resultScreen/tardlingSpritesheet"), fontLetters, FlxPoint.get(49, 62)));
    songName.text = params.title;
    songName.letterSpacing = -15;
    songName.angle = -4.4;
+    songName.zIndex = 1000;
+
+    difficulty = new FlxSprite(555);
+    difficulty.zIndex = 1000;
+
+    clearPercentSmall = new ClearPercentCounter(FlxG.width / 2 + 300, FlxG.height / 2 - 100, 100, true);
+    clearPercentSmall.zIndex = 1000;
+    clearPercentSmall.visible = false;
+
+    bgFlash = FlxGradient.createGradientFlxSprite(FlxG.width, FlxG.height, [0xFFFFEB69, 0xFFFFE66A], 90);
+
+    resultsAnim = FunkinSprite.createSparrow(-200, -10, "resultScreen/results");
+
+    ratingsPopin = FunkinSprite.createSparrow(-150, 120, "resultScreen/ratingsPopin");
+
+    scorePopin = FunkinSprite.createSparrow(-180, 520, "resultScreen/scorePopin");
+
+    highscoreNew = new FlxSprite(310, 570);
+
+    score = new ResultScore(35, 305, 10, params.scoreData.score);
+  }
+
+  override function create():Void
+  {
+    if (FlxG.sound.music != null) FlxG.sound.music.stop();
+
+    // We need multiple cameras so we can put one at an angle.
+    cameraScroll.angle = -3.8;
+
+    cameraBG.bgColor = FlxColor.MAGENTA;
+    cameraScroll.bgColor = FlxColor.TRANSPARENT;
+    cameraEverything.bgColor = FlxColor.TRANSPARENT;
+
+    FlxG.cameras.add(cameraBG, false);
+    FlxG.cameras.add(cameraScroll, false);
+    FlxG.cameras.add(cameraEverything, false);
+
+    FlxG.cameras.setDefaultDrawTarget(cameraEverything, true);
+
+    // Reset the camera zoom on the results screen.
+    FlxG.camera.zoom = 1.0;
+
+    var bg:FlxSprite = FlxGradient.createGradientFlxSprite(FlxG.width, FlxG.height, [0xFFFECC5C, 0xFFFDC05C], 90);
+    bg.scrollFactor.set();
+    bg.zIndex = 10;
+    bg.cameras = [cameraBG];
+    add(bg);
+
+    bgFlash.scrollFactor.set();
+    bgFlash.visible = false;
+    bgFlash.zIndex = 20;
+    bgFlash.cameras = [cameraBG];
+    add(bgFlash);
+
+    // The sound system which falls into place behind the score text. Plays every time!
+    var soundSystem:FlxSprite = FunkinSprite.createSparrow(-15, -180, 'resultScreen/soundSystem');
+    soundSystem.animation.addByPrefix("idle", "sound system", 24, false);
+    soundSystem.visible = false;
+    new FlxTimer().start(0.3, _ -> {
+      soundSystem.animation.play("idle");
+      soundSystem.visible = true;
+    });
+    soundSystem.zIndex = 1100;
+    add(soundSystem);
+
+    switch (rank)
+    {
+      case PERFECT | PERFECT_GOLD:
+        bfPerfect = new FlxAtlasSprite(370, -180, Paths.animateAtlas("resultScreen/results-bf/resultsPERFECT", "shared"));
+        bfPerfect.visible = false;
+        bfPerfect.zIndex = 500;
+        add(bfPerfect);
+
+        bfPerfect.anim.onComplete = () -> {
+          if (bfPerfect != null)
+          {
+            bfPerfect.anim.curFrame = 137;
+            bfPerfect.anim.play(); // unpauses this anim, since it's on PlayOnce!
+          }
+        };
+
+      case EXCELLENT:
+        bfExcellent = new FlxAtlasSprite(380, -170, Paths.animateAtlas("resultScreen/results-bf/resultsEXCELLENT", "shared"));
+        bfExcellent.visible = false;
+        bfExcellent.zIndex = 500;
+        add(bfExcellent);
+
+        bfExcellent.onAnimationFinish.add((animName) -> {
+          if (bfExcellent != null)
+          {
+            bfExcellent.playAnimation('Loop Start');
+          }
+        });
+
+      case GREAT:
+        bfGreat = new FlxAtlasSprite(640, 200, Paths.animateAtlas("resultScreen/results-bf/resultsGREAT", "shared"));
+        bfGreat.visible = false;
+        bfGreat.zIndex = 500;
+        add(bfGreat);
+
+        bfGreat.onAnimationFinish.add((animName) -> {
+          if (bfGreat != null)
+          {
+            bfGreat.playAnimation('Loop Start');
+          }
+        });
+
+      case GOOD:
+        gfGood = FunkinSprite.createSparrow(625, 325, 'resultScreen/results-bf/resultsGOOD/resultGirlfriendGOOD');
+        gfGood.animation.addByPrefix("clap", "Girlfriend Good Anim", 24, false);
+        gfGood.visible = false;
+        gfGood.zIndex = 500;
+        gfGood.animation.finishCallback = _ -> {
+          if (gfGood != null)
+          {
+            gfGood.animation.play('clap', true, false, 9);
+          }
+        };
+        add(gfGood);
+
+        bfGood = FunkinSprite.createSparrow(640, -200, 'resultScreen/results-bf/resultsGOOD/resultBoyfriendGOOD');
+        bfGood.animation.addByPrefix("fall", "Boyfriend Good Anim0", 24, false);
+        bfGood.visible = false;
+        bfGood.zIndex = 501;
+        bfGood.animation.finishCallback = function(_) {
+          if (bfGood != null)
+          {
+            bfGood.animation.play('fall', true, false, 14);
+          }
+        };
+        add(bfGood);
+
+      case SHIT:
+        bfShit = new FlxAtlasSprite(0, 20, Paths.animateAtlas("resultScreen/results-bf/resultsSHIT", "shared"));
+        bfShit.visible = false;
+        bfShit.zIndex = 500;
+        add(bfShit);
+        bfShit.onAnimationFinish.add((animName) -> {
+          if (bfShit != null)
+          {
+            bfShit.playAnimation('Loop Start');
+          }
+        });
+    }
+
+    var diffSpr:String = 'dif${params?.difficultyId ?? 'Normal'}';
+    difficulty.loadGraphic(Paths.image("resultScreen/" + diffSpr));
+    add(difficulty);
+
    add(songName);

    var angleRad = songName.angle * Math.PI / 180;
    speedOfTween.x = -1.0 * Math.cos(angleRad);
    speedOfTween.y = -1.0 * Math.sin(angleRad);

-    timerThenSongName();
+    timerThenSongName(1.0, false);

    songName.shader = maskShaderSongName;
    difficulty.shader = maskShaderDifficulty;
@ -178,35 +250,53 @@ class ResultState extends MusicBeatSubState

    var blackTopBar:FlxSprite = new FlxSprite().loadGraphic(Paths.image("resultScreen/topBarBlack"));
    blackTopBar.y = -blackTopBar.height;
-    FlxTween.tween(blackTopBar, {y: 0}, 0.4, {ease: FlxEase.quartOut, startDelay: 0.5});
+    FlxTween.tween(blackTopBar, {y: 0}, 0.4, {ease: FlxEase.quartOut});
+    blackTopBar.zIndex = 1010;
    add(blackTopBar);

-    var resultsAnim:FunkinSprite = FunkinSprite.createSparrow(-200, -10, "resultScreen/results");
    resultsAnim.animation.addByPrefix("result", "results instance 1", 24, false);
-    resultsAnim.animation.play("result");
+    resultsAnim.visible = false;
+    resultsAnim.zIndex = 1200;
    add(resultsAnim);
+    new FlxTimer().start(0.3, _ -> {
+      resultsAnim.visible = true;
+      resultsAnim.animation.play("result");
+    });

-    var ratingsPopin:FunkinSprite = FunkinSprite.createSparrow(-150, 120, "resultScreen/ratingsPopin");
    ratingsPopin.animation.addByPrefix("idle", "Categories", 24, false);
    ratingsPopin.visible = false;
+    ratingsPopin.zIndex = 1200;
    add(ratingsPopin);
+    new FlxTimer().start(1.0, _ -> {
+      ratingsPopin.visible = true;
+      ratingsPopin.animation.play("idle");
+    });

-    var scorePopin:FunkinSprite = FunkinSprite.createSparrow(-180, 520, "resultScreen/scorePopin");
    scorePopin.animation.addByPrefix("score", "tally score", 24, false);
    scorePopin.visible = false;
+    scorePopin.zIndex = 1200;
    add(scorePopin);
+    new FlxTimer().start(1.0, _ -> {
+      scorePopin.visible = true;
+      scorePopin.animation.play("score");
+      scorePopin.animation.finishCallback = anim -> {
+        score.visible = true;
+        score.animateNumbers();
+      };
+    });

-    var highscoreNew:FlxSprite = new FlxSprite(310, 570);
    highscoreNew.frames = Paths.getSparrowAtlas("resultScreen/highscoreNew");
    highscoreNew.animation.addByPrefix("new", "NEW HIGHSCORE", 24);
    highscoreNew.visible = false;
    highscoreNew.setGraphicSize(Std.int(highscoreNew.width * 0.8));
    highscoreNew.updateHitbox();
+    highscoreNew.zIndex = 1200;
    add(highscoreNew);

    var hStuf:Int = 50;

    var ratingGrp:FlxTypedGroup<TallyCounter> = new FlxTypedGroup<TallyCounter>();
+    ratingGrp.zIndex = 1200;
    add(ratingGrp);

    /**
@ -236,32 +326,143 @@ class ResultState extends MusicBeatSubState
    var tallyMissed:TallyCounter = new TallyCounter(260, (hStuf * 9) + extraYOffset, params.scoreData.tallies.missed, 0xFFC68AE6);
    ratingGrp.add(tallyMissed);

-    var score:ResultScore = new ResultScore(35, 305, 10, params.scoreData.score);
    score.visible = false;
+    score.zIndex = 1200;
    add(score);

    for (ind => rating in ratingGrp.members)
    {
      rating.visible = false;
-      new FlxTimer().start((0.3 * ind) + 0.55, _ -> {
+      new FlxTimer().start((0.3 * ind) + 1.20, _ -> {
        rating.visible = true;
        FlxTween.tween(rating, {curNumber: rating.neededNumber}, 0.5, {ease: FlxEase.quartOut});
      });
    }

-    new FlxTimer().start(0.5, _ -> {
-      ratingsPopin.animation.play("idle");
-      ratingsPopin.visible = true;
+    ratingsPopin.animation.finishCallback = anim -> {
+      startRankTallySequence();
+
+      if (params.isNewHighscore ?? false)
+      {
+        highscoreNew.visible = true;
+        highscoreNew.animation.play("new");
+        FlxTween.tween(highscoreNew, {y: highscoreNew.y + 10}, 0.8, {ease: FlxEase.quartOut});
+      }
+      else
+      {
+        highscoreNew.visible = false;
+      }
+    };
+
+    new FlxTimer().start(rank.getMusicDelay(), _ -> {
+      if (rank.hasMusicIntro())
+      {
+        // Play the intro music.
+        var introMusic:String = Paths.music(rank.getMusicPath() + '/' + rank.getMusicPath() + '-intro');
+        FunkinSound.load(introMusic, 1.0, false, true, true, () -> {
+          FunkinSound.playMusic(rank.getMusicPath(),
+            {
+              startingVolume: 1.0,
+              overrideExisting: true,
+              restartTrack: true,
+              loop: rank.shouldMusicLoop()
+            });
+        });
+      }
+      else
+      {
+        FunkinSound.playMusic(rank.getMusicPath(),
+          {
+            startingVolume: 1.0,
+            overrideExisting: true,
+            restartTrack: true,
+            loop: rank.shouldMusicLoop()
+          });
+      }
+    });
+
+    refresh();
+
+    super.create();
+  }
+
+  var rankTallyTimer:Null<FlxTimer> = null;
+  var clearPercentTarget:Int = 100;
+  var clearPercentLerp:Int = 0;
+
+  function startRankTallySequence():Void
+  {
+    var clearPercentFloat = (params.scoreData.tallies.sick + params.scoreData.tallies.good) / params.scoreData.tallies.totalNotes * 100;
+    clearPercentTarget = Math.floor(clearPercentFloat);
+    // Prevent off-by-one errors.
+
+    clearPercentLerp = Std.int(Math.max(0, clearPercentTarget - 36));
+
+    trace('Clear percent target: ' + clearPercentFloat + ', round: ' + clearPercentTarget);
+
+    var clearPercentCounter:ClearPercentCounter = new ClearPercentCounter(FlxG.width / 2 + 300, FlxG.height / 2 - 100, clearPercentLerp);
+    FlxTween.tween(clearPercentCounter, {curNumber: clearPercentTarget}, 1.5,
+      {
+        ease: FlxEase.quartOut,
+        onUpdate: _ -> {
+          // Only play the tick sound if the number increased.
+          if (clearPercentLerp != clearPercentCounter.curNumber)
+          {
+            clearPercentLerp = clearPercentCounter.curNumber;
+            FunkinSound.playOnce(Paths.sound('scrollMenu'));
+          }
+        },
+        onComplete: _ -> {
+          // Play confirm sound.
+          FunkinSound.playOnce(Paths.sound('confirmMenu'));
+
+          // Flash background.
+          bgFlash.visible = true;
+          FlxTween.tween(bgFlash, {alpha: 0}, 0.4);
+
+          // Just to be sure that the lerp didn't mess things up.
+          clearPercentCounter.curNumber = clearPercentTarget;
+
+          clearPercentCounter.flash(true);
+          new FlxTimer().start(0.4, _ -> {
+            clearPercentCounter.flash(false);
+          });
+
+          displayRankText();
+
+          // previously 2.0 seconds
+          new FlxTimer().start(0.25, _ -> {
+            FlxTween.tween(clearPercentCounter, {alpha: 0}, 0.5,
+              {
+                startDelay: 0.5,
+                ease: FlxEase.quartOut,
+                onComplete: _ -> {
+                  remove(clearPercentCounter);
+                }
+              });
+
+            afterRankTallySequence();
+          });
+        }
+      });
+    clearPercentCounter.zIndex = 450;
+    add(clearPercentCounter);
+
+    if (ratingsPopin == null)
+    {
+      trace("Could not build ratingsPopin!");
+    }
+    else
+    {
+      // ratingsPopin.animation.play("idle");
+      // ratingsPopin.visible = true;

      ratingsPopin.animation.finishCallback = anim -> {
-        scorePopin.animation.play("score");
-        scorePopin.animation.finishCallback = anim -> {
-          score.visible = true;
-          score.animateNumbers();
-        };
-        scorePopin.visible = true;
+        // scorePopin.animation.play("score");

-        if (params.isNewHighscore)
+        // scorePopin.visible = true;
+
+        if (params.isNewHighscore ?? false)
        {
          highscoreNew.visible = true;
          highscoreNew.animation.play("new");
@ -272,47 +473,112 @@ class ResultState extends MusicBeatSubState
          highscoreNew.visible = false;
        }
      };
+    }

-      switch (resultsVariation)
-      {
-        // case SHIT:
-        // bfSHIT.visible = true;
-        // bfSHIT.playAnimation("");
-
-        case NORMAL:
-          boyfriend.animation.play('fall');
-          boyfriend.visible = true;
-
-          new FlxTimer().start((1 / 24) * 12, _ -> {
-            bgFlash.visible = true;
-            FlxTween.tween(bgFlash, {alpha: 0}, 0.4);
-            new FlxTimer().start((1 / 24) * 2, _ ->
-              {
-                // bgFlash.alpha = 0.5;
-
-                // bgFlash.visible = false;
-              });
-          });
-
-          new FlxTimer().start((1 / 24) * 22, _ -> {
-            // plays about 22 frames (at 24fps timing) after bf spawns in
-            gf.animation.play('clap', true);
-            gf.visible = true;
-          });
-        // case PERFECT:
-        //          bfPerfect.visible = true;
-        //          bfPerfect.playAnimation("");
-
-        // bfGfExcellent.visible = true;
-        // bfGfExcellent.playAnimation("");
-        default:
-      }
-    });
-
-    super.create();
+    refresh();
  }

-  function timerThenSongName():Void
+  function displayRankText():Void
+  {
+    var rankTextVert:FlxBackdrop = new FlxBackdrop(Paths.image(rank.getVerTextAsset()), Y, 0, 30);
+    rankTextVert.x = FlxG.width - 64;
+    rankTextVert.y = 100;
+    rankTextVert.zIndex = 990;
+    add(rankTextVert);
+
+    // Scrolling.
+    rankTextVert.velocity.y = -50;
+
+    for (i in 0...10)
+    {
+      var rankTextBack:FlxBackdrop = new FlxBackdrop(Paths.image(rank.getHorTextAsset()), X, 10, 0);
+      rankTextBack.x = FlxG.width / 2 - 320;
+      rankTextBack.y = 50 + (150 * i / 2) + 10;
+      // rankTextBack.angle = -3.8;
+      rankTextBack.zIndex = 100;
+      rankTextBack.cameras = [cameraScroll];
+      add(rankTextBack);
+
+      // Scrolling.
+      rankTextBack.velocity.x = (i % 2 == 0) ? -10.0 : 10.0;
+    }
+
+    refresh();
+  }
+
+  function afterRankTallySequence():Void
+  {
+    showSmallClearPercent();
+
+    switch (rank)
+    {
+      case PERFECT | PERFECT_GOLD:
+        if (bfPerfect == null)
+        {
+          trace("Could not build PERFECT animation!");
+        }
+        else
+        {
+          bfPerfect.visible = true;
+          bfPerfect.playAnimation('');
+        }
+      case EXCELLENT:
+        if (bfExcellent == null)
+        {
+          trace("Could not build EXCELLENT animation!");
+        }
+        else
+        {
+          bfExcellent.visible = true;
+          bfExcellent.playAnimation('Intro');
+        }
+      case GREAT:
+        if (bfGreat == null)
+        {
+          trace("Could not build GREAT animation!");
+        }
+        else
+        {
+          bfGreat.visible = true;
+          bfGreat.playAnimation('Intro');
+        }
+      case SHIT:
+        if (bfShit == null)
+        {
+          trace("Could not build SHIT animation!");
+        }
+        else
+        {
+          bfShit.visible = true;
+          bfShit.playAnimation('Intro');
+        }
+      case GOOD:
+        if (bfGood == null)
+        {
+          trace("Could not build GOOD animation!");
+        }
+        else
+        {
+          bfGood.animation.play('fall');
+          bfGood.visible = true;
+          new FlxTimer().start((1 / 24) * 22, _ -> {
+            // plays about 22 frames (at 24fps timing) after bf spawns in
+            if (gfGood != null)
+            {
+              gfGood.animation.play('clap', true);
+              gfGood.visible = true;
+            }
+            else
+            {
+              trace("Could not build GOOD animation!");
+            }
+          });
+        }
+      default:
+    }
+  }
+
+  function timerThenSongName(timerLength:Float = 3.0, autoScroll:Bool = true):Void
  {
    movingSongStuff = false;

@ -323,21 +589,47 @@ class ResultState extends MusicBeatSubState
    difficulty.y = -difficulty.height;
    FlxTween.tween(difficulty, {y: diffYTween}, 0.5, {ease: FlxEase.expoOut, startDelay: 0.8});

+    if (clearPercentSmall != null)
+    {
+      clearPercentSmall.x = (difficulty.x + difficulty.width) + 60;
+      clearPercentSmall.y = -clearPercentSmall.height;
+      FlxTween.tween(clearPercentSmall, {y: 122 - 5}, 0.5, {ease: FlxEase.expoOut, startDelay: 0.8});
+    }
+
    songName.y = -songName.height;
    var fuckedupnumber = (10) * (songName.text.length / 15);
-    FlxTween.tween(songName, {y: diffYTween - 35 - fuckedupnumber}, 0.5, {ease: FlxEase.expoOut, startDelay: 0.9});
-    songName.x = (difficulty.x + difficulty.width) + 20;
+    FlxTween.tween(songName, {y: diffYTween - 25 - fuckedupnumber}, 0.5, {ease: FlxEase.expoOut, startDelay: 0.9});
+    songName.x = clearPercentSmall.x + clearPercentSmall.width - 30;

-    new FlxTimer().start(3, _ -> {
+    new FlxTimer().start(timerLength, _ -> {
      var tempSpeed = FlxPoint.get(speedOfTween.x, speedOfTween.y);

      speedOfTween.set(0, 0);
      FlxTween.tween(speedOfTween, {x: tempSpeed.x, y: tempSpeed.y}, 0.7, {ease: FlxEase.quadIn});

-      movingSongStuff = true;
+      movingSongStuff = (autoScroll);
    });
  }

+  function showSmallClearPercent():Void
+  {
+    if (clearPercentSmall != null)
+    {
+      add(clearPercentSmall);
+      clearPercentSmall.visible = true;
+      clearPercentSmall.flash(true);
+      new FlxTimer().start(0.4, _ -> {
+        clearPercentSmall.flash(false);
+      });
+
+      clearPercentSmall.curNumber = clearPercentTarget;
+      clearPercentSmall.zIndex = 1000;
+      refresh();
+    }
+
+    movingSongStuff = true;
+  }
+
  var movingSongStuff:Bool = false;
  var speedOfTween:FlxPoint = FlxPoint.get(-1, 1);

@ -345,11 +637,9 @@ class ResultState extends MusicBeatSubState
  {
    super.draw();

-    if (songName != null)
-    {
-      songName.clipRect = FlxRect.get(Math.max(0, 540 - songName.x), 0, FlxG.width, songName.height);
-      // PROBABLY SHOULD FIX MEMORY FREE OR WHATEVER THE PUT() FUNCTION DOES !!!! FEELS LIKE IT STUTTERS!!!
-    }
+    songName.clipRect = FlxRect.get(Math.max(0, 520 - songName.x), 0, FlxG.width, songName.height);
+
+    // PROBABLY SHOULD FIX MEMORY FREE OR WHATEVER THE PUT() FUNCTION DOES !!!! FEELS LIKE IT STUTTERS!!!

    // if (songName != null && songName.frame != null)
    // maskShaderSongName.frameUV = songName.frame.uv;
@ -364,8 +654,10 @@ class ResultState extends MusicBeatSubState
    {
      songName.x += speedOfTween.x;
      difficulty.x += speedOfTween.x;
+      clearPercentSmall.x += speedOfTween.x;
      songName.y += speedOfTween.y;
      difficulty.y += speedOfTween.y;
+      clearPercentSmall.y += speedOfTween.y;

      if (songName.x + songName.width < 100)
      {
@ -382,20 +674,34 @@ class ResultState extends MusicBeatSubState

    if (controls.PAUSE)
    {
-      FlxTween.tween(FlxG.sound.music, {volume: 0}, 0.8);
-      FlxTween.tween(FlxG.sound.music, {pitch: 3}, 0.1,
-        {
-          onComplete: _ -> {
-            FlxTween.tween(FlxG.sound.music, {pitch: 0.5}, 0.4);
-          }
-        });
+      if (FlxG.sound.music != null)
+      {
+        FlxTween.tween(FlxG.sound.music, {volume: 0}, 0.8);
+        FlxTween.tween(FlxG.sound.music, {pitch: 3}, 0.1,
+          {
+            onComplete: _ -> {
+              FlxTween.tween(FlxG.sound.music, {pitch: 0.5}, 0.4);
+            }
+          });
+      }
      if (params.storyMode)
      {
        openSubState(new funkin.ui.transition.StickerSubState(null, (sticker) -> new StoryMenuState(sticker)));
      }
      else
      {
-        openSubState(new funkin.ui.transition.StickerSubState(null, (sticker) -> FreeplayState.build(null, sticker)));
+        openSubState(new funkin.ui.transition.StickerSubState(null, (sticker) -> FreeplayState.build(
+          {
+            {
+              fromResults:
+                {
+                  oldRank: Scoring.calculateRank(params?.prevScoreData),
+                  newRank: rank,
+                  songId: params.songId,
+                  difficultyId: params.difficultyId
+                }
+            }
+          }, sticker)));
      }
    }

@ -403,14 +709,6 @@ class ResultState extends MusicBeatSubState
  }
 }

-enum abstract ResultVariations(String)
-{
-  var PERFECT;
-  var EXCELLENT;
-  var NORMAL;
-  var SHIT;
-}
-
 typedef ResultsStateParams =
 {
  /**
@ -423,13 +721,26 @@ typedef ResultsStateParams =
   */
  var title:String;

+  var songId:String;
+
  /**
   * Whether the displayed score is a new highscore
   */
-  var isNewHighscore:Bool;
+  var ?isNewHighscore:Bool;
+
+  /**
+   * The difficulty ID of the song/week we just played.
+   * @default Normal
+   */
+  var ?difficultyId:String;

  /**
   * The score, accuracy, and judgements.
   */
  var scoreData:SaveScoreData;
+
+  /**
+   * The previous score data, used for rank comparision.
+   */
+  var ?prevScoreData:SaveScoreData;
 };
--- a/source/funkin/play/components/ClearPercentCounter.hx
+++ b/source/funkin/play/components/ClearPercentCounter.hx
@ -0,0 +1,137 @@
+package funkin.play.components;
+
+import funkin.graphics.FunkinSprite;
+import funkin.graphics.shaders.PureColor;
+import flixel.FlxSprite;
+import flixel.group.FlxGroup.FlxTypedGroup;
+import flixel.group.FlxSpriteGroup.FlxTypedSpriteGroup;
+import flixel.math.FlxMath;
+import flixel.tweens.FlxEase;
+import flixel.tweens.FlxTween;
+import flixel.text.FlxText.FlxTextAlign;
+import funkin.util.MathUtil;
+import flixel.util.FlxColor;
+
+/**
+ * Numerical counters used to display the clear percent.
+ */
+class ClearPercentCounter extends FlxTypedSpriteGroup<FlxSprite>
+{
+  public var curNumber(default, set):Int = 0;
+
+  var numberChanged:Bool = false;
+
+  function set_curNumber(val:Int):Int
+  {
+    numberChanged = true;
+    return curNumber = val;
+  }
+
+  var small:Bool = false;
+  var flashShader:PureColor;
+
+  public function new(x:Float, y:Float, startingNumber:Int = 0, small:Bool = false)
+  {
+    super(x, y);
+
+    flashShader = new PureColor(FlxColor.WHITE);
+    flashShader.colorSet = true;
+
+    curNumber = startingNumber;
+
+    this.small = small;
+
+    var clearPercentText:FunkinSprite = FunkinSprite.create(0, 0, 'resultScreen/clearPercent/clearPercentText${small ? 'Small' : ''}');
+    clearPercentText.x = small ? 40 : 0;
+    add(clearPercentText);
+
+    drawNumbers();
+  }
+
+  /**
+   * Make the counter flash turn white or stop being all white.
+   * @param enabled Whether the counter should be white.
+   */
+  public function flash(enabled:Bool):Void
+  {
+    for (member in members)
+    {
+      member.shader = enabled ? flashShader : null;
+    }
+  }
+
+  var tmr:Float = 0;
+
+  override function update(elapsed:Float)
+  {
+    super.update(elapsed);
+
+    if (numberChanged) drawNumbers();
+  }
+
+  function drawNumbers()
+  {
+    var seperatedScore:Array<Int> = [];
+    var tempCombo:Int = Math.round(curNumber);
+
+    while (tempCombo != 0)
+    {
+      seperatedScore.push(tempCombo % 10);
+      tempCombo = Math.floor(tempCombo / 10);
+    }
+
+    if (seperatedScore.length == 0) seperatedScore.push(0);
+
+    seperatedScore.reverse();
+
+    for (ind => num in seperatedScore)
+    {
+      var digitIndex = ind + 1;
+      // If there's only one digit, move it to the right
+      // If there's three digits, move them all to the left
+      var digitOffset = (seperatedScore.length == 1) ? 1 : (seperatedScore.length == 3) ? -1 : 0;
+      var digitSize = small ? 32 : 72;
+      var digitHeightOffset = small ? -4 : 0;
+
+      var xPos = (digitIndex - 1 + digitOffset) * (digitSize * this.scale.x);
+      xPos += small ? -24 : 0;
+      var yPos = (digitIndex - 1 + digitOffset) * (digitHeightOffset * this.scale.y);
+      yPos += small ? 0 : 72;
+
+      if (digitIndex >= members.length)
+      {
+        // Three digits = LLR because the 1 and 0 won't be the same anyway.
+        var variant:Bool = (seperatedScore.length == 3) ? (digitIndex >= 2) : (digitIndex >= 1);
+        // var variant:Bool = (seperatedScore.length % 2 != 0) ? (digitIndex % 2 == 0) : (digitIndex % 2 == 1);
+        var numb:ClearPercentNumber = new ClearPercentNumber(xPos, yPos, num, variant, this.small);
+        numb.scale.set(this.scale.x, this.scale.y);
+        add(numb);
+      }
+      else
+      {
+        members[digitIndex].animation.play(Std.string(num));
+        // Reset the position of the number
+        members[digitIndex].x = xPos + this.x;
+        members[digitIndex].y = yPos + this.y;
+      }
+    }
+  }
+}
+
+class ClearPercentNumber extends FlxSprite
+{
+  public function new(x:Float, y:Float, digit:Int, variant:Bool, small:Bool)
+  {
+    super(x, y);
+
+    frames = Paths.getSparrowAtlas('resultScreen/clearPercent/clearPercentNumber${small ? 'Small' : variant ? 'Right' : 'Left'}');
+
+    for (i in 0...10)
+    {
+      animation.addByPrefix('$i', 'number $i 0', 24, false);
+    }
+
+    animation.play('$digit');
+    updateHitbox();
+  }
+}
--- a/source/funkin/play/components/HealthIcon.hx
+++ b/source/funkin/play/components/HealthIcon.hx
@ -24,7 +24,7 @@ import funkin.util.MathUtil;
 *     - i.e. `PlayState.instance.iconP1.playAnimation("losing")`
 *   - Scripts can also utilize all functionality that a normal FlxSprite would have access to, such as adding supplimental animations.
 *     - i.e. `PlayState.instance.iconP1.animation.addByPrefix("jumpscare", "jumpscare", 24, false);`
- * @author MasterEric
+ * @author EliteMasterEric
 */
@:nullSafety
 class HealthIcon extends FunkinSprite
--- a/source/funkin/play/notes/Strumline.hx
+++ b/source/funkin/play/notes/Strumline.hx
@ -171,6 +171,20 @@ class Strumline extends FlxSpriteGroup
    updateNotes();
  }

+  /**
+   * Returns `true` if no notes are in range of the strumline and the player can spam without penalty.
+   */
+  public function mayGhostTap():Bool
+  {
+    // TODO: Refine this. Only querying "can be hit" is too tight but "is being rendered" is too loose.
+    // Also, if you just hit a note, there should be a (short) period where this is off so you can't spam.
+
+    // If there are any notes on screen, we can't ghost tap.
+    return notes.members.filter(function(note:NoteSprite) {
+      return note != null && note.alive && !note.hasBeenHit;
+    }).length == 0;
+  }
+
  /**
   * Return notes that are within `Constants.HIT_WINDOW` ms of the strumline.
   * @return An array of `NoteSprite` objects.
--- a/source/funkin/play/scoring/Scoring.hx
+++ b/source/funkin/play/scoring/Scoring.hx
@ -1,5 +1,7 @@
 package funkin.play.scoring;

+import funkin.save.Save.SaveScoreData;
+
 /**
 * Which system to use when scoring and judging notes.
 */
@ -344,4 +346,178 @@ class Scoring
      return 'miss';
    }
  }
+
+  public static function calculateRank(scoreData:Null<SaveScoreData>):Null<ScoringRank>
+  {
+    if (scoreData == null) return null;
+
+    // Perfect (Platinum) is a Sick Full Clear
+    var isPerfectGold = scoreData.tallies.sick == scoreData.tallies.totalNotes;
+    if (isPerfectGold) return ScoringRank.PERFECT_GOLD;
+
+    // Else, use the standard grades
+
+    // Grade % (only good and sick), 1.00 is a full combo
+    var grade = (scoreData.tallies.sick + scoreData.tallies.good) / scoreData.tallies.totalNotes;
+    // Clear % (including bad and shit). 1.00 is a full clear but not a full combo
+    var clear = (scoreData.tallies.totalNotesHit) / scoreData.tallies.totalNotes;
+
+    if (grade == Constants.RANK_PERFECT_THRESHOLD)
+    {
+      return ScoringRank.PERFECT;
+    }
+    else if (grade >= Constants.RANK_EXCELLENT_THRESHOLD)
+    {
+      return ScoringRank.EXCELLENT;
+    }
+    else if (grade >= Constants.RANK_GREAT_THRESHOLD)
+    {
+      return ScoringRank.GREAT;
+    }
+    else if (grade >= Constants.RANK_GOOD_THRESHOLD)
+    {
+      return ScoringRank.GOOD;
+    }
+    else
+    {
+      return ScoringRank.SHIT;
+    }
+  }
+}
+
+enum abstract ScoringRank(String)
+{
+  var PERFECT_GOLD;
+  var PERFECT;
+  var EXCELLENT;
+  var GREAT;
+  var GOOD;
+  var SHIT;
+
+  /**
+   * Delay in seconds
+   */
+  public function getMusicDelay():Float
+  {
+    switch (abstract)
+    {
+      case PERFECT_GOLD | PERFECT:
+        // return 2.5;
+        return 5.0;
+      case EXCELLENT:
+        return 1.75;
+      default:
+        return 3.5;
+    }
+  }
+
+  public function getMusicPath():String
+  {
+    switch (abstract)
+    {
+      case PERFECT_GOLD:
+        return 'resultsPERFECT';
+      case PERFECT:
+        return 'resultsPERFECT';
+      case EXCELLENT:
+        return 'resultsEXCELLENT';
+      case GREAT:
+        return 'resultsNORMAL';
+      case GOOD:
+        return 'resultsNORMAL';
+      case SHIT:
+        return 'resultsSHIT';
+      default:
+        return 'resultsNORMAL';
+    }
+  }
+
+  public function hasMusicIntro():Bool
+  {
+    switch (abstract)
+    {
+      case EXCELLENT:
+        return true;
+      case SHIT:
+        return true;
+      default:
+        return false;
+    }
+  }
+
+  public function getFreeplayRankIconAsset():Null<String>
+  {
+    switch (abstract)
+    {
+      case PERFECT_GOLD:
+        return 'PERFECTSICK';
+      case PERFECT:
+        return 'PERFECT';
+      case EXCELLENT:
+        return 'EXCELLENT';
+      case GREAT:
+        return 'GREAT';
+      case GOOD:
+        return 'GOOD';
+      case SHIT:
+        return 'LOSS';
+      default:
+        return null;
+    }
+  }
+
+  public function shouldMusicLoop():Bool
+  {
+    switch (abstract)
+    {
+      case PERFECT_GOLD | PERFECT | EXCELLENT | GREAT | GOOD:
+        return true;
+      case SHIT:
+        return false;
+      default:
+        return false;
+    }
+  }
+
+  public function getHorTextAsset()
+  {
+    switch (abstract)
+    {
+      case PERFECT_GOLD:
+        return 'resultScreen/rankText/rankScrollPERFECT';
+      case PERFECT:
+        return 'resultScreen/rankText/rankScrollPERFECT';
+      case EXCELLENT:
+        return 'resultScreen/rankText/rankScrollEXCELLENT';
+      case GREAT:
+        return 'resultScreen/rankText/rankScrollGREAT';
+      case GOOD:
+        return 'resultScreen/rankText/rankScrollGOOD';
+      case SHIT:
+        return 'resultScreen/rankText/rankScrollLOSS';
+      default:
+        return 'resultScreen/rankText/rankScrollGOOD';
+    }
+  }
+
+  public function getVerTextAsset()
+  {
+    switch (abstract)
+    {
+      case PERFECT_GOLD:
+        return 'resultScreen/rankText/rankTextPERFECT';
+      case PERFECT:
+        return 'resultScreen/rankText/rankTextPERFECT';
+      case EXCELLENT:
+        return 'resultScreen/rankText/rankTextEXCELLENT';
+      case GREAT:
+        return 'resultScreen/rankText/rankTextGREAT';
+      case GOOD:
+        return 'resultScreen/rankText/rankTextGOOD';
+      case SHIT:
+        return 'resultScreen/rankText/rankTextLOSS';
+      default:
+        return 'resultScreen/rankText/rankTextGOOD';
+    }
+  }
 }
--- a/source/funkin/play/song/Song.hx
+++ b/source/funkin/play/song/Song.hx
@ -120,6 +120,18 @@ class Song implements IPlayStateScriptedClass implements IRegistryEntry<SongMeta
    return DEFAULT_ARTIST;
  }

+  /**
+   * The artist of the song.
+   */
+  public var charter(get, never):String;
+
+  function get_charter():String
+  {
+    if (_data != null) return _data?.charter ?? 'Unknown';
+    if (_metadata.size() > 0) return _metadata.get(Constants.DEFAULT_VARIATION)?.charter ?? 'Unknown';
+    return Constants.DEFAULT_CHARTER;
+  }
+
  /**
   * @param id The ID of the song to load.
   * @param ignoreErrors If false, an exception will be thrown if the song data could not be loaded.
@ -270,6 +282,7 @@ class Song implements IPlayStateScriptedClass implements IRegistryEntry<SongMeta

        difficulty.songName = metadata.songName;
        difficulty.songArtist = metadata.artist;
+        difficulty.charter = metadata.charter ?? Constants.DEFAULT_CHARTER;
        difficulty.timeFormat = metadata.timeFormat;
        difficulty.divisions = metadata.divisions;
        difficulty.timeChanges = metadata.timeChanges;
@ -334,6 +347,7 @@ class Song implements IPlayStateScriptedClass implements IRegistryEntry<SongMeta
        {
          difficulty.songName = metadata.songName;
          difficulty.songArtist = metadata.artist;
+          difficulty.charter = metadata.charter ?? Constants.DEFAULT_CHARTER;
          difficulty.timeFormat = metadata.timeFormat;
          difficulty.divisions = metadata.divisions;
          difficulty.timeChanges = metadata.timeChanges;
@ -399,6 +413,27 @@ class Song implements IPlayStateScriptedClass implements IRegistryEntry<SongMeta
    return null;
  }

+  /**
+   * Given that this character is selected in the Freeplay menu,
+   * which variations should be available?
+   * @param charId The character ID to query.
+   * @return An array of available variations.
+   */
+  public function getVariationsByCharId(?charId:String):Array<String>
+  {
+    if (charId == null) charId = Constants.DEFAULT_CHARACTER;
+
+    if (variations.contains(charId))
+    {
+      return [charId];
+    }
+    else
+    {
+      // TODO: How to exclude character variations while keeping other custom variations?
+      return variations;
+    }
+  }
+
  /**
   * List all the difficulties in this song.
   *
@ -418,12 +453,16 @@ class Song implements IPlayStateScriptedClass implements IRegistryEntry<SongMeta
    // so we have to map it to the actual difficulty names.
    // We also filter out difficulties that don't match the variation or that don't exist.

-    var diffFiltered:Array<String> = difficulties.keys().array().map(function(diffId:String):Null<String> {
-      var difficulty:Null<SongDifficulty> = difficulties.get(diffId);
-      if (difficulty == null) return null;
-      if (variationIds.length > 0 && !variationIds.contains(difficulty.variation)) return null;
-      return difficulty.difficulty;
-    }).nonNull().unique();
+    var diffFiltered:Array<String> = difficulties.keys()
+      .array()
+      .map(function(diffId:String):Null<String> {
+        var difficulty:Null<SongDifficulty> = difficulties.get(diffId);
+        if (difficulty == null) return null;
+        if (variationIds.length > 0 && !variationIds.contains(difficulty.variation)) return null;
+        return difficulty.difficulty;
+      })
+      .filterNull()
+      .distinct();

    diffFiltered = diffFiltered.filter(function(diffId:String):Bool {
      if (showHidden) return true;
@ -565,6 +604,7 @@ class SongDifficulty

  public var songName:String = Constants.DEFAULT_SONGNAME;
  public var songArtist:String = Constants.DEFAULT_ARTIST;
+  public var charter:String = Constants.DEFAULT_CHARTER;
  public var timeFormat:SongTimeFormat = Constants.DEFAULT_TIMEFORMAT;
  public var divisions:Null<Int> = null;
  public var looped:Bool = false;
--- a/source/funkin/save/Save.hx
+++ b/source/funkin/save/Save.hx
@ -1,21 +1,22 @@
 package funkin.save;

 import flixel.util.FlxSave;
-import funkin.save.migrator.SaveDataMigrator;
-import thx.semver.Version;
 import funkin.input.Controls.Device;
+import funkin.play.scoring.Scoring;
+import funkin.play.scoring.Scoring.ScoringRank;
 import funkin.save.migrator.RawSaveData_v1_0_0;
 import funkin.save.migrator.SaveDataMigrator;
+import funkin.save.migrator.SaveDataMigrator;
 import funkin.ui.debug.charting.ChartEditorState.ChartEditorLiveInputStyle;
 import funkin.ui.debug.charting.ChartEditorState.ChartEditorTheme;
-import thx.semver.Version;
 import funkin.util.SerializerUtil;
+import thx.semver.Version;
+import thx.semver.Version;

@:nullSafety
 class Save
 {
-  // Version 2.0.2 adds attributes to `optionsChartEditor`, that should return default values if they are null.
-  public static final SAVE_DATA_VERSION:thx.semver.Version = "2.0.3";
+  public static final SAVE_DATA_VERSION:thx.semver.Version = "2.0.4";
  public static final SAVE_DATA_VERSION_RULE:thx.semver.VersionRule = "2.0.x";

  // We load this version's saves from a new save path, to maintain SOME level of backwards compatibility.
@ -53,7 +54,8 @@ class Save
  public function new(?data:RawSaveData)
  {
    if (data == null) this.data = Save.getDefault();
-    else this.data = data;
+    else
+      this.data = data;
  }

  public static function getDefault():RawSaveData
@ -77,6 +79,9 @@ class Save
          levels: [],
          songs: [],
        },
+
+      favoriteSongs: [],
+
      options:
        {
          // Reasonable defaults.
@ -489,6 +494,11 @@ class Save
    return song.get(difficultyId);
  }

+  public function getSongRank(songId:String, difficultyId:String = 'normal'):Null<ScoringRank>
+  {
+    return Scoring.calculateRank(getSongScore(songId, difficultyId));
+  }
+
  /**
   * Apply the score the user achieved for a given song on a given difficulty.
   */
@ -554,6 +564,35 @@ class Save
    return false;
  }

+  public function isSongFavorited(id:String):Bool
+  {
+    if (data.favoriteSongs == null)
+    {
+      data.favoriteSongs = [];
+      flush();
+    };
+
+    return data.favoriteSongs.contains(id);
+  }
+
+  public function favoriteSong(id:String):Void
+  {
+    if (!isSongFavorited(id))
+    {
+      data.favoriteSongs.push(id);
+      flush();
+    }
+  }
+
+  public function unfavoriteSong(id:String):Void
+  {
+    if (isSongFavorited(id))
+    {
+      data.favoriteSongs.remove(id);
+      flush();
+    }
+  }
+
  public function getControls(playerId:Int, inputType:Device):Null<SaveControlsData>
  {
    switch (inputType)
@ -714,6 +753,7 @@ class Save

 /**
 * An anonymous structure containingg all the user's save data.
+ * Isn't stored with JSON, stored with some sort of Haxe built-in serialization?
 */
 typedef RawSaveData =
 {
@ -724,8 +764,6 @@ typedef RawSaveData =
  /**
   * A semantic versioning string for the save data format.
   */
-  @:jcustomparse(funkin.data.DataParse.semverVersion)
-  @:jcustomwrite(funkin.data.DataWrite.semverVersion)
  var version:Version;

  var api:SaveApiData;
@ -740,6 +778,12 @@ typedef RawSaveData =
   */
  var options:SaveDataOptions;

+  /**
+   * The user's favorited songs in the Freeplay menu,
+   * as a list of song IDs.
+   */
+  var favoriteSongs:Array<String>;
+
  var mods:SaveDataMods;

  /**
@ -809,11 +853,6 @@ typedef SaveScoreData =
   * The count of each judgement hit.
   */
  var tallies:SaveScoreTallyData;
-
-  /**
-   * The accuracy percentage.
-   */
-  var accuracy:Float;
 }

 typedef SaveScoreTallyData =
--- a/source/funkin/save/changelog.md
+++ b/source/funkin/save/changelog.md
@ -5,6 +5,9 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).

+## [2.0.4] - 2024-05-21
+### Added
+- `favoriteSongs:Array<String>` to `Save`

 ## [2.0.3] - 2024-01-09
 ### Added
--- a/source/funkin/save/migrator/SaveDataMigrator.hx
+++ b/source/funkin/save/migrator/SaveDataMigrator.hx
@ -3,7 +3,6 @@ package funkin.save.migrator;
 import funkin.save.Save;
 import funkin.save.migrator.RawSaveData_v1_0_0;
 import thx.semver.Version;
-import funkin.util.StructureUtil;
 import funkin.util.VersionUtil;

@:nullSafety
@ -24,16 +23,20 @@ class SaveDataMigrator
    }
    else
    {
+      // Sometimes the Haxe serializer has issues with the version so we fix it here.
+      version = VersionUtil.repairVersion(version);
      if (VersionUtil.validateVersion(version, Save.SAVE_DATA_VERSION_RULE))
      {
-        // Simply import the structured data.
-        var save:Save = new Save(StructureUtil.deepMerge(Save.getDefault(), inputData));
+        // Import the structured data.
+        var saveDataWithDefaults:RawSaveData = cast thx.Objects.deepCombine(Save.getDefault(), inputData);
+        var save:Save = new Save(saveDataWithDefaults);
        return save;
      }
      else
      {
-        trace('[SAVE] Invalid save data version! Returning blank data.');
-        trace(inputData);
+        var message:String = 'Error migrating save data, expected ${Save.SAVE_DATA_VERSION}.';
+        lime.app.Application.current.window.alert(message, "Save Data Failure");
+        trace('[SAVE] ' + message);
        return new Save(Save.getDefault());
      }
    }
@ -118,7 +121,7 @@ class SaveDataMigrator
    var scoreDataEasy:SaveScoreData =
      {
        score: inputSaveData.songScores.get('${levelId}-easy') ?? 0,
-        accuracy: inputSaveData.songCompletion.get('${levelId}-easy') ?? 0.0,
+        // accuracy: inputSaveData.songCompletion.get('${levelId}-easy') ?? 0.0,
        tallies:
          {
            sick: 0,
@ -137,7 +140,7 @@ class SaveDataMigrator
    var scoreDataNormal:SaveScoreData =
      {
        score: inputSaveData.songScores.get('${levelId}') ?? 0,
-        accuracy: inputSaveData.songCompletion.get('${levelId}') ?? 0.0,
+        // accuracy: inputSaveData.songCompletion.get('${levelId}') ?? 0.0,
        tallies:
          {
            sick: 0,
@ -156,7 +159,7 @@ class SaveDataMigrator
    var scoreDataHard:SaveScoreData =
      {
        score: inputSaveData.songScores.get('${levelId}-hard') ?? 0,
-        accuracy: inputSaveData.songCompletion.get('${levelId}-hard') ?? 0.0,
+        // accuracy: inputSaveData.songCompletion.get('${levelId}-hard') ?? 0.0,
        tallies:
          {
            sick: 0,
@ -178,7 +181,6 @@ class SaveDataMigrator
    var scoreDataEasy:SaveScoreData =
      {
        score: 0,
-        accuracy: 0,
        tallies:
          {
            sick: 0,
@ -196,14 +198,13 @@ class SaveDataMigrator
    for (songId in songIds)
    {
      scoreDataEasy.score = Std.int(Math.max(scoreDataEasy.score, inputSaveData.songScores.get('${songId}-easy') ?? 0));
-      scoreDataEasy.accuracy = Math.max(scoreDataEasy.accuracy, inputSaveData.songCompletion.get('${songId}-easy') ?? 0.0);
+      // scoreDataEasy.accuracy = Math.max(scoreDataEasy.accuracy, inputSaveData.songCompletion.get('${songId}-easy') ?? 0.0);
    }
    result.setSongScore(songIds[0], 'easy', scoreDataEasy);

    var scoreDataNormal:SaveScoreData =
      {
        score: 0,
-        accuracy: 0,
        tallies:
          {
            sick: 0,
@ -221,14 +222,13 @@ class SaveDataMigrator
    for (songId in songIds)
    {
      scoreDataNormal.score = Std.int(Math.max(scoreDataNormal.score, inputSaveData.songScores.get('${songId}') ?? 0));
-      scoreDataNormal.accuracy = Math.max(scoreDataNormal.accuracy, inputSaveData.songCompletion.get('${songId}') ?? 0.0);
+      // scoreDataNormal.accuracy = Math.max(scoreDataNormal.accuracy, inputSaveData.songCompletion.get('${songId}') ?? 0.0);
    }
    result.setSongScore(songIds[0], 'normal', scoreDataNormal);

    var scoreDataHard:SaveScoreData =
      {
        score: 0,
-        accuracy: 0,
        tallies:
          {
            sick: 0,
@ -246,7 +246,7 @@ class SaveDataMigrator
    for (songId in songIds)
    {
      scoreDataHard.score = Std.int(Math.max(scoreDataHard.score, inputSaveData.songScores.get('${songId}-hard') ?? 0));
-      scoreDataHard.accuracy = Math.max(scoreDataHard.accuracy, inputSaveData.songCompletion.get('${songId}-hard') ?? 0.0);
+      // scoreDataHard.accuracy = Math.max(scoreDataHard.accuracy, inputSaveData.songCompletion.get('${songId}-hard') ?? 0.0);
    }
    result.setSongScore(songIds[0], 'hard', scoreDataHard);
  }
--- a/source/funkin/ui/credits/CreditsDataHandler.hx
+++ b/source/funkin/ui/credits/CreditsDataHandler.hx
@ -54,7 +54,7 @@ class CreditsDataHandler
          body: [
            {line: 'ninjamuffin99'},
            {line: 'PhantomArcade'},
-            {line: 'KawaiSprite'},
+            {line: 'Kawai Sprite'},
            {line: 'evilsk8r'},
          ]
        }
--- a/source/funkin/ui/debug/charting/ChartEditorState.hx
+++ b/source/funkin/ui/debug/charting/ChartEditorState.hx
@ -137,7 +137,7 @@ using Lambda;
 *
 * Some functionality is split into handler classes to help maintain my sanity.
 *
- * @author MasterEric
+ * @author EliteMasterEric
 */
 // @:nullSafety

@ -1270,7 +1270,7 @@ class ChartEditorState extends UIState // UIState derives from MusicBeatState
    var result:Null<SongMetadata> = songMetadata.get(selectedVariation);
    if (result == null)
    {
-      result = new SongMetadata('DadBattle', 'Kawai Sprite', selectedVariation);
+      result = new SongMetadata('Default Song Name', Constants.DEFAULT_ARTIST, selectedVariation);
      songMetadata.set(selectedVariation, result);
    }
    return result;
@ -4566,8 +4566,8 @@ class ChartEditorState extends UIState // UIState derives from MusicBeatState
            }

            gridGhostHoldNote.visible = true;
-            gridGhostHoldNote.noteData = gridGhostNote.noteData;
-            gridGhostHoldNote.noteDirection = gridGhostNote.noteData.getDirection();
+            gridGhostHoldNote.noteData = currentPlaceNoteData;
+            gridGhostHoldNote.noteDirection = currentPlaceNoteData.getDirection();
            gridGhostHoldNote.setHeightDirectly(dragLengthPixels, true);

            gridGhostHoldNote.updateHoldNotePosition(renderedHoldNotes);
--- a/source/funkin/ui/debug/charting/components/ChartEditorHoldNoteSprite.hx
+++ b/source/funkin/ui/debug/charting/components/ChartEditorHoldNoteSprite.hx
@ -36,6 +36,8 @@ class ChartEditorHoldNoteSprite extends SustainTrail
    zoom *= 0.7;
    zoom *= ChartEditorState.GRID_SIZE / Strumline.STRUMLINE_SIZE;

+    flipY = false;
+
    setup();
  }

--- a/source/funkin/ui/debug/charting/handlers/ChartEditorImportExportHandler.hx
+++ b/source/funkin/ui/debug/charting/handlers/ChartEditorImportExportHandler.hx
@ -384,17 +384,34 @@ class ChartEditorImportExportHandler
      if (variationId == '')
      {
        var variationMetadata:Null<SongMetadata> = state.songMetadata.get(variation);
-        if (variationMetadata != null) zipEntries.push(FileUtil.makeZIPEntry('${state.currentSongId}-metadata.json', variationMetadata.serialize()));
+        if (variationMetadata != null)
+        {
+          variationMetadata.version = funkin.data.song.SongRegistry.SONG_METADATA_VERSION;
+          variationMetadata.generatedBy = funkin.data.song.SongRegistry.DEFAULT_GENERATEDBY;
+          zipEntries.push(FileUtil.makeZIPEntry('${state.currentSongId}-metadata.json', variationMetadata.serialize()));
+        }
        var variationChart:Null<SongChartData> = state.songChartData.get(variation);
-        if (variationChart != null) zipEntries.push(FileUtil.makeZIPEntry('${state.currentSongId}-chart.json', variationChart.serialize()));
+        if (variationChart != null)
+        {
+          variationChart.version = funkin.data.song.SongRegistry.SONG_CHART_DATA_VERSION;
+          variationChart.generatedBy = funkin.data.song.SongRegistry.DEFAULT_GENERATEDBY;
+          zipEntries.push(FileUtil.makeZIPEntry('${state.currentSongId}-chart.json', variationChart.serialize()));
+        }
      }
      else
      {
        var variationMetadata:Null<SongMetadata> = state.songMetadata.get(variation);
-        if (variationMetadata != null) zipEntries.push(FileUtil.makeZIPEntry('${state.currentSongId}-metadata-$variationId.json',
-          variationMetadata.serialize()));
+        if (variationMetadata != null)
+        {
+          zipEntries.push(FileUtil.makeZIPEntry('${state.currentSongId}-metadata-$variationId.json', variationMetadata.serialize()));
+        }
        var variationChart:Null<SongChartData> = state.songChartData.get(variation);
-        if (variationChart != null) zipEntries.push(FileUtil.makeZIPEntry('${state.currentSongId}-chart-$variationId.json', variationChart.serialize()));
+        if (variationChart != null)
+        {
+          variationChart.version = funkin.data.song.SongRegistry.SONG_CHART_DATA_VERSION;
+          variationChart.generatedBy = funkin.data.song.SongRegistry.DEFAULT_GENERATEDBY;
+          zipEntries.push(FileUtil.makeZIPEntry('${state.currentSongId}-chart-$variationId.json', variationChart.serialize()));
+        }
      }
    }

--- a/source/funkin/ui/debug/charting/toolboxes/ChartEditorMetadataToolbox.hx
+++ b/source/funkin/ui/debug/charting/toolboxes/ChartEditorMetadataToolbox.hx
@ -29,6 +29,7 @@ class ChartEditorMetadataToolbox extends ChartEditorBaseToolbox
 {
  var inputSongName:TextField;
  var inputSongArtist:TextField;
+  var inputSongCharter:TextField;
  var inputStage:DropDown;
  var inputNoteStyle:DropDown;
  var buttonCharacterPlayer:Button;
@ -89,6 +90,20 @@ class ChartEditorMetadataToolbox extends ChartEditorBaseToolbox
      }
    };

+    inputSongCharter.onChange = function(event:UIEvent) {
+      var valid:Bool = event.target.text != null && event.target.text != '';
+
+      if (valid)
+      {
+        inputSongCharter.removeClass('invalid-value');
+        chartEditorState.currentSongMetadata.charter = event.target.text;
+      }
+      else
+      {
+        chartEditorState.currentSongMetadata.charter = null;
+      }
+    };
+
    inputStage.onChange = function(event:UIEvent) {
      var valid:Bool = event.data != null && event.data.id != null;

@ -178,6 +193,7 @@ class ChartEditorMetadataToolbox extends ChartEditorBaseToolbox

    inputSongName.value = chartEditorState.currentSongMetadata.songName;
    inputSongArtist.value = chartEditorState.currentSongMetadata.artist;
+    inputSongCharter.value = chartEditorState.currentSongMetadata.charter;
    inputStage.value = chartEditorState.currentSongMetadata.playData.stage;
    inputNoteStyle.value = chartEditorState.currentSongMetadata.playData.noteStyle;
    inputBPM.value = chartEditorState.currentSongMetadata.timeChanges[0].bpm;
--- a/source/funkin/ui/freeplay/AlbumRoll.hx
+++ b/source/funkin/ui/freeplay/AlbumRoll.hx
@ -38,7 +38,7 @@ class AlbumRoll extends FlxSpriteGroup

  var newAlbumArt:FlxAtlasSprite;

-  // var difficultyStars:DifficultyStars;
+  var difficultyStars:DifficultyStars;
  var _exitMovers:Null<FreeplayState.ExitMoverData>;

  var albumData:Album;
@ -65,9 +65,9 @@ class AlbumRoll extends FlxSpriteGroup

    add(newAlbumArt);

-    // difficultyStars = new DifficultyStars(140, 39);
-    // difficultyStars.stars.visible = false;
-    // add(difficultyStars);
+    difficultyStars = new DifficultyStars(140, 39);
+    difficultyStars.stars.visible = false;
+    add(difficultyStars);
  }

  function onAlbumFinish(animName:String):Void
@ -86,9 +86,14 @@ class AlbumRoll extends FlxSpriteGroup
  {
    if (albumId == null)
    {
-      // difficultyStars.stars.visible = false;
+      this.visible = false;
+      difficultyStars.stars.visible = false;
      return;
    }
+    else
+    {
+      this.visible = true;
+    }

    albumData = AlbumRegistry.instance.fetchEntry(albumId);

@ -144,10 +149,10 @@ class AlbumRoll extends FlxSpriteGroup
    newAlbumArt.visible = true;
    newAlbumArt.playAnimation(animNames.get('$albumId-active'), false, false, false);

-    // difficultyStars.stars.visible = false;
+    difficultyStars.stars.visible = false;
    new FlxTimer().start(0.75, function(_) {
      // showTitle();
-      // showStars();
+      showStars();
    });
  }

@ -156,16 +161,17 @@ class AlbumRoll extends FlxSpriteGroup
    newAlbumArt.playAnimation(animNames.get('$albumId-trans'), false, false, false);
  }

-  // public function setDifficultyStars(?difficulty:Int):Void
-  // {
-  //   if (difficulty == null) return;
-  //   difficultyStars.difficulty = difficulty;
-  // }
-  // /**
-  //  * Make the album stars visible.
-  //  */
-  // public function showStars():Void
-  // {
-  //   difficultyStars.stars.visible = false; // true;
-  // }
+  public function setDifficultyStars(?difficulty:Int):Void
+  {
+    if (difficulty == null) return;
+    difficultyStars.difficulty = difficulty;
+  }
+
+  /**
+   * Make the album stars visible.
+   */
+  public function showStars():Void
+  {
+    difficultyStars.stars.visible = true; // true;
+  }
 }
--- a/source/funkin/ui/freeplay/CapsuleText.hx
+++ b/source/funkin/ui/freeplay/CapsuleText.hx
@ -4,6 +4,12 @@ import openfl.filters.BitmapFilterQuality;
 import flixel.text.FlxText;
 import flixel.group.FlxSpriteGroup;
 import funkin.graphics.shaders.GaussianBlurShader;
+import funkin.graphics.shaders.LeftMaskShader;
+import flixel.math.FlxRect;
+import flixel.tweens.FlxEase;
+import flixel.util.FlxTimer;
+import flixel.tweens.FlxTween;
+import openfl.display.BlendMode;

 class CapsuleText extends FlxSpriteGroup
 {
@ -13,6 +19,15 @@ class CapsuleText extends FlxSpriteGroup

  public var text(default, set):String;

+  var maskShaderSongName:LeftMaskShader = new LeftMaskShader();
+
+  public var clipWidth(default, set):Int = 255;
+
+  public var tooLong:Bool = false;
+
+  // 255, 27 normal
+  // 220, 27 favourited
+
  public function new(x:Float, y:Float, songTitle:String, size:Float)
  {
    super(x, y);
@ -36,6 +51,30 @@ class CapsuleText extends FlxSpriteGroup
    return text;
  }

+  // ???? none
+  // 255, 27 normal
+  // 220, 27 favourited
+
+  function set_clipWidth(value:Int):Int
+  {
+    resetText();
+    if (whiteText.width > value)
+    {
+      tooLong = true;
+
+      blurredText.clipRect = new FlxRect(0, 0, value, blurredText.height);
+      whiteText.clipRect = new FlxRect(0, 0, value, whiteText.height);
+    }
+    else
+    {
+      tooLong = false;
+
+      blurredText.clipRect = null;
+      whiteText.clipRect = null;
+    }
+    return clipWidth = value;
+  }
+
  function set_text(value:String):String
  {
    if (value == null) return value;
@ -51,6 +90,102 @@ class CapsuleText extends FlxSpriteGroup
      new openfl.filters.GlowFilter(0x00ccff, 1, 5, 5, 210, BitmapFilterQuality.MEDIUM),
      // new openfl.filters.BlurFilter(5, 5, BitmapFilterQuality.LOW)
    ];
+
    return text = value;
  }
+
+  var moveTimer:FlxTimer = new FlxTimer();
+  var moveTween:FlxTween;
+
+  public function initMove():Void
+  {
+    moveTimer.start(0.6, (timer) -> {
+      moveTextRight();
+    });
+  }
+
+  function moveTextRight():Void
+  {
+    var distToMove:Float = whiteText.width - clipWidth;
+    moveTween = FlxTween.tween(whiteText.offset, {x: distToMove}, 2,
+      {
+        onUpdate: function(_) {
+          whiteText.clipRect = new FlxRect(whiteText.offset.x, 0, clipWidth, whiteText.height);
+          blurredText.offset = whiteText.offset;
+          blurredText.clipRect = new FlxRect(whiteText.offset.x, 0, clipWidth, blurredText.height);
+        },
+        onComplete: function(_) {
+          moveTimer.start(0.3, (timer) -> {
+            moveTextLeft();
+          });
+        },
+        ease: FlxEase.sineInOut
+      });
+  }
+
+  function moveTextLeft():Void
+  {
+    moveTween = FlxTween.tween(whiteText.offset, {x: 0}, 2,
+      {
+        onUpdate: function(_) {
+          whiteText.clipRect = new FlxRect(whiteText.offset.x, 0, clipWidth, whiteText.height);
+          blurredText.offset = whiteText.offset;
+          blurredText.clipRect = new FlxRect(whiteText.offset.x, 0, clipWidth, blurredText.height);
+        },
+        onComplete: function(_) {
+          moveTimer.start(0.3, (timer) -> {
+            moveTextRight();
+          });
+        },
+        ease: FlxEase.sineInOut
+      });
+  }
+
+  public function resetText():Void
+  {
+    if (moveTween != null) moveTween.cancel();
+    if (moveTimer != null) moveTimer.cancel();
+    whiteText.offset.x = 0;
+    whiteText.clipRect = new FlxRect(whiteText.offset.x, 0, clipWidth, whiteText.height);
+    blurredText.clipRect = new FlxRect(whiteText.offset.x, 0, clipWidth, whiteText.height);
+  }
+
+  var flickerState:Bool = false;
+  var flickerTimer:FlxTimer;
+
+  public function flickerText():Void
+  {
+    resetText();
+    flickerTimer = new FlxTimer().start(1 / 24, flickerProgress, 19);
+  }
+
+  function flickerProgress(timer:FlxTimer):Void
+  {
+    if (flickerState == true)
+    {
+      whiteText.blend = BlendMode.ADD;
+      blurredText.blend = BlendMode.ADD;
+      blurredText.color = 0xFFFFFFFF;
+      whiteText.color = 0xFFFFFFFF;
+      whiteText.textField.filters = [
+        new openfl.filters.GlowFilter(0xFFFFFF, 1, 5, 5, 210, BitmapFilterQuality.MEDIUM),
+        // new openfl.filters.BlurFilter(5, 5, BitmapFilterQuality.LOW)
+      ];
+    }
+    else
+    {
+      blurredText.color = 0xFF00aadd;
+      whiteText.color = 0xFFDDDDDD;
+      whiteText.textField.filters = [
+        new openfl.filters.GlowFilter(0xDDDDDD, 1, 5, 5, 210, BitmapFilterQuality.MEDIUM),
+        // new openfl.filters.BlurFilter(5, 5, BitmapFilterQuality.LOW)
+      ];
+    }
+    flickerState = !flickerState;
+  }
+
+  override function update(elapsed:Float):Void
+  {
+    super.update(elapsed);
+  }
 }
--- a/source/funkin/ui/freeplay/DJBoyfriend.hx
+++ b/source/funkin/ui/freeplay/DJBoyfriend.hx
@ -82,6 +82,8 @@ class DJBoyfriend extends FlxAtlasSprite
    return anims;
  }

+  var lowPumpLoopPoint:Int = 4;
+
  public override function update(elapsed:Float):Void
  {
    super.update(elapsed);
@ -114,6 +116,14 @@ class DJBoyfriend extends FlxAtlasSprite
      case Confirm:
        if (getCurrentAnimation() != 'Boyfriend DJ confirm') playFlashAnimation('Boyfriend DJ confirm', false);
        timeSinceSpook = 0;
+      case PumpIntro:
+        if (getCurrentAnimation() != 'Boyfriend DJ fist pump') playFlashAnimation('Boyfriend DJ fist pump', false);
+        if (getCurrentAnimation() == 'Boyfriend DJ fist pump' && anim.curFrame >= 4)
+        {
+          anim.play("Boyfriend DJ fist pump", true, false, 0);
+        }
+      case FistPump:
+
      case Spook:
        if (getCurrentAnimation() != 'bf dj afk')
        {
@ -174,6 +184,12 @@ class DJBoyfriend extends FlxAtlasSprite
        currentState = Idle;
      case "Boyfriend DJ confirm":

+      case "Boyfriend DJ fist pump":
+        currentState = Idle;
+
+      case "Boyfriend DJ loss reaction 1":
+        currentState = Idle;
+
      case "Boyfriend DJ watchin tv OG":
        var frame:Int = FlxG.random.bool(33) ? 112 : 166;

@ -275,6 +291,23 @@ class DJBoyfriend extends FlxAtlasSprite
    currentState = Confirm;
  }

+  public function fistPump():Void
+  {
+    currentState = PumpIntro;
+  }
+
+  public function pumpFist():Void
+  {
+    currentState = FistPump;
+    anim.play("Boyfriend DJ fist pump", true, false, 4);
+  }
+
+  public function pumpFistBad():Void
+  {
+    currentState = FistPump;
+    anim.play("Boyfriend DJ loss reaction 1", true, false, 4);
+  }
+
  public inline function addOffset(name:String, x:Float = 0, y:Float = 0)
  {
    animOffsets[name] = [x, y];
@ -331,6 +364,8 @@ enum DJBoyfriendState
  Intro;
  Idle;
  Confirm;
+  PumpIntro;
+  FistPump;
  Spook;
  TV;
 }
--- a/source/funkin/ui/freeplay/DifficultyStars.hx
+++ b/source/funkin/ui/freeplay/DifficultyStars.hx
@ -0,0 +1,106 @@
+package funkin.ui.freeplay;
+
+import flixel.group.FlxSpriteGroup;
+import funkin.graphics.adobeanimate.FlxAtlasSprite;
+import funkin.graphics.shaders.HSVShader;
+
+class DifficultyStars extends FlxSpriteGroup
+{
+  /**
+   * Internal handler var for difficulty... ranges from 0... to 15
+   * 0 is 1 star... 15 is 0 stars!
+   */
+  var curDifficulty(default, set):Int = 0;
+
+  /**
+   * Range between 0 and 15
+   */
+  public var difficulty(default, set):Int = 1;
+
+  public var stars:FlxAtlasSprite;
+
+  var flames:FreeplayFlames;
+
+  var hsvShader:HSVShader;
+
+  public function new(x:Float, y:Float)
+  {
+    super(x, y);
+
+    hsvShader = new HSVShader();
+
+    flames = new FreeplayFlames(0, 0);
+    add(flames);
+
+    stars = new FlxAtlasSprite(0, 0, Paths.animateAtlas("freeplay/freeplayStars"));
+    stars.anim.play("diff stars");
+    add(stars);
+
+    stars.shader = hsvShader;
+
+    for (memb in flames.members)
+      memb.shader = hsvShader;
+  }
+
+  override function update(elapsed:Float):Void
+  {
+    super.update(elapsed);
+
+    // "loops" the current animation
+    // for clarity, the animation file looks like
+    // frame : stars
+    // 0-99: 1 star
+    // 100-199: 2 stars
+    // ......
+    // 1300-1499: 15 stars
+    // 1500 : 0 stars
+    if (curDifficulty < 15 && stars.anim.curFrame >= (curDifficulty + 1) * 100)
+    {
+      stars.anim.play("diff stars", true, false, curDifficulty * 100);
+    }
+  }
+
+  function set_difficulty(value:Int):Int
+  {
+    difficulty = value;
+
+    if (difficulty <= 0)
+    {
+      difficulty = 0;
+      curDifficulty = 15;
+    }
+    else if (difficulty <= 15)
+    {
+      difficulty = value;
+      curDifficulty = difficulty - 1;
+    }
+    else
+    {
+      difficulty = 15;
+      curDifficulty = difficulty - 1;
+    }
+
+    if (difficulty > 10) flames.flameCount = difficulty - 10;
+    else
+      flames.flameCount = 0;
+
+    return difficulty;
+  }
+
+  function set_curDifficulty(value:Int):Int
+  {
+    curDifficulty = value;
+    if (curDifficulty == 15)
+    {
+      stars.anim.play("diff stars", true, false, 1500);
+      stars.anim.pause();
+    }
+    else
+    {
+      stars.anim.curFrame = Std.int(curDifficulty * 100);
+      stars.anim.play("diff stars", true, false, curDifficulty * 100);
+    }
+
+    return curDifficulty;
+  }
+}
--- a/source/funkin/ui/freeplay/FreeplayFlames.hx
+++ b/source/funkin/ui/freeplay/FreeplayFlames.hx
@ -50,8 +50,19 @@ class FreeplayFlames extends FlxSpriteGroup
    }
  }

+  var timers:Array<FlxTimer> = [];
+
  function set_flameCount(value:Int):Int
  {
+    // Stop all existing timers.
+    // This fixes a bug where quickly switching difficulties would show flames.
+    for (timer in timers)
+    {
+      timer.active = false;
+      timer.destroy();
+      timers.remove(timer);
+    }
+
    this.flameCount = value;
    var visibleCount:Int = 0;
    for (i in 0...5)
@ -62,10 +73,18 @@ class FreeplayFlames extends FlxSpriteGroup
      {
        if (!flame.visible)
        {
-          new FlxTimer().start(flameTimer * visibleCount, function(_) {
+          var nextTimer:FlxTimer = new FlxTimer().start(flameTimer * visibleCount, function(currentTimer:FlxTimer) {
+            if (i >= this.flameCount)
+            {
+              trace('EARLY EXIT');
+              return;
+            }
+            timers.remove(currentTimer);
            flame.animation.play("flame", true);
            flame.visible = true;
          });
+          timers.push(nextTimer);
+
          visibleCount++;
        }
      }
--- a/source/funkin/ui/freeplay/FreeplayState.hx
+++ b/source/funkin/ui/freeplay/FreeplayState.hx
@ -1,5 +1,6 @@
 package funkin.ui.freeplay;

+import funkin.graphics.adobeanimate.FlxAtlasSprite;
 import flixel.addons.transition.FlxTransitionableState;
 import flixel.addons.ui.FlxInputText;
 import flixel.FlxCamera;
@ -10,6 +11,7 @@ import flixel.group.FlxSpriteGroup.FlxTypedSpriteGroup;
 import flixel.input.touch.FlxTouch;
 import flixel.math.FlxAngle;
 import flixel.math.FlxPoint;
+import openfl.display.BlendMode;
 import flixel.system.debug.watch.Tracker.TrackerProfile;
 import flixel.text.FlxText;
 import flixel.tweens.FlxEase;
@ -33,12 +35,16 @@ import funkin.ui.story.Level;
 import funkin.save.Save;
 import funkin.save.Save.SaveScoreData;
 import funkin.ui.AtlasText;
+import funkin.play.scoring.Scoring;
+import funkin.play.scoring.Scoring.ScoringRank;
 import funkin.ui.mainmenu.MainMenuState;
 import funkin.ui.MusicBeatSubState;
 import funkin.ui.transition.LoadingState;
 import funkin.ui.transition.StickerSubState;
 import funkin.util.MathUtil;
 import lime.utils.Assets;
+import flixel.tweens.misc.ShakeTween;
+import funkin.effects.IntervalShake;

 /**
 * Parameters used to initialize the FreeplayState.
@ -46,6 +52,34 @@ import lime.utils.Assets;
 typedef FreeplayStateParams =
 {
  ?character:String,
+
+  ?fromResults:FromResultsParams,
+};
+
+/**
+ * A set of parameters for transitioning to the FreeplayState from the ResultsState.
+ */
+typedef FromResultsParams =
+{
+  /**
+   * The previous rank the song hand, if any. Null if it had no score before.
+   */
+  var ?oldRank:ScoringRank;
+
+  /**
+   * The new rank the song has.
+   */
+  var newRank:ScoringRank;
+
+  /**
+   * The song ID to play the animation on.
+   */
+  var songId:String;
+
+  /**
+   * The difficulty ID to play the animation on.
+   */
+  var difficultyId:String;
 };

 /**
@ -70,6 +104,7 @@ class FreeplayState extends MusicBeatSubState

  /**
   * For the audio preview, the duration of the fade-out effect.
+   *
   */
  public static final FADE_OUT_DURATION:Float = 0.25;

@ -121,8 +156,6 @@ class FreeplayState extends MusicBeatSubState
  var curCapsule:SongMenuItem;
  var curPlaying:Bool = false;

-  var displayedVariations:Array<String>;
-
  var dj:DJBoyfriend;

  var ostName:FlxText;
@ -136,10 +169,37 @@ class FreeplayState extends MusicBeatSubState
  public static var rememberedDifficulty:Null<String> = Constants.DEFAULT_DIFFICULTY;
  public static var rememberedSongId:Null<String> = 'tutorial';

+  var funnyCam:FunkinCamera;
+  var rankCamera:FunkinCamera;
+  var rankBg:FunkinSprite;
+  var rankVignette:FlxSprite;
+
+  var backingTextYeah:FlxAtlasSprite;
+  var orangeBackShit:FunkinSprite;
+  var alsoOrangeLOL:FunkinSprite;
+  var pinkBack:FunkinSprite;
+  var confirmGlow:FlxSprite;
+  var confirmGlow2:FlxSprite;
+  var confirmTextGlow:FlxSprite;
+
+  var moreWays:BGScrollingText;
+  var funnyScroll:BGScrollingText;
+  var txtNuts:BGScrollingText;
+  var funnyScroll2:BGScrollingText;
+  var moreWays2:BGScrollingText;
+  var funnyScroll3:BGScrollingText;
+
+  var bgDad:FlxSprite;
+  var cardGlow:FlxSprite;
+
+  var fromResultsParams:Null<FromResultsParams> = null;
+
  public function new(?params:FreeplayStateParams, ?stickers:StickerSubState)
  {
    currentCharacter = params?.character ?? Constants.DEFAULT_CHARACTER;

+    fromResultsParams = params?.fromResults;
+
    if (stickers != null)
    {
      stickerSubState = stickers;
@ -185,10 +245,6 @@ class FreeplayState extends MusicBeatSubState
    // Add a null entry that represents the RANDOM option
    songs.push(null);

-    // TODO: This makes custom variations disappear from Freeplay. Figure out a better solution later.
-    // Default character (BF) shows default and Erect variations. Pico shows only Pico variations.
-    displayedVariations = (currentCharacter == 'bf') ? [Constants.DEFAULT_VARIATION, 'erect'] : [currentCharacter];
-
    // programmatically adds the songs via LevelRegistry and SongRegistry
    for (levelId in LevelRegistry.instance.listSortedLevelIds())
    {
@ -210,7 +266,8 @@ class FreeplayState extends MusicBeatSubState
          continue;
        }

-        // Only display songs which actually have available charts for the current character.
+        // Only display songs which actually have available difficulties for the current character.
+        var displayedVariations = song.getVariationsByCharId(currentCharacter);
        var availableDifficultiesForSong:Array<String> = song.listDifficulties(displayedVariations, false);
        if (availableDifficultiesForSong.length == 0) continue;

@ -231,17 +288,17 @@ class FreeplayState extends MusicBeatSubState
    trace(FlxG.camera.initialZoom);
    trace(FlxCamera.defaultZoom);

-    var pinkBack:FunkinSprite = FunkinSprite.create('freeplay/pinkBack');
+    pinkBack = FunkinSprite.create('freeplay/pinkBack');
    pinkBack.color = 0xFFFFD4E9; // sets it to pink!
    pinkBack.x -= pinkBack.width;

    FlxTween.tween(pinkBack, {x: 0}, 0.6, {ease: FlxEase.quartOut});
    add(pinkBack);

-    var orangeBackShit:FunkinSprite = new FunkinSprite(84, 440).makeSolidColor(Std.int(pinkBack.width), 75, 0xFFFEDA00);
+    orangeBackShit = new FunkinSprite(84, 440).makeSolidColor(Std.int(pinkBack.width), 75, 0xFFFEDA00);
    add(orangeBackShit);

-    var alsoOrangeLOL:FunkinSprite = new FunkinSprite(0, orangeBackShit.y).makeSolidColor(100, Std.int(orangeBackShit.height), 0xFFFFD400);
+    alsoOrangeLOL = new FunkinSprite(0, orangeBackShit.y).makeSolidColor(100, Std.int(orangeBackShit.height), 0xFFFFD400);
    add(alsoOrangeLOL);

    exitMovers.set([pinkBack, orangeBackShit, alsoOrangeLOL],
@ -256,13 +313,30 @@ class FreeplayState extends MusicBeatSubState
    orangeBackShit.visible = false;
    alsoOrangeLOL.visible = false;

+    confirmTextGlow = new FlxSprite(-8, 115).loadGraphic(Paths.image('freeplay/glowingText'));
+    confirmTextGlow.blend = BlendMode.ADD;
+    confirmTextGlow.visible = false;
+
+    confirmGlow = new FlxSprite(-30, 240).loadGraphic(Paths.image('freeplay/confirmGlow'));
+    confirmGlow.blend = BlendMode.ADD;
+
+    confirmGlow2 = new FlxSprite(confirmGlow.x, confirmGlow.y).loadGraphic(Paths.image('freeplay/confirmGlow2'));
+
+    confirmGlow.visible = false;
+    confirmGlow2.visible = false;
+
+    add(confirmGlow2);
+    add(confirmGlow);
+
+    add(confirmTextGlow);
+
    var grpTxtScrolls:FlxGroup = new FlxGroup();
    add(grpTxtScrolls);
    grpTxtScrolls.visible = false;

    FlxG.debugger.addTrackerProfile(new TrackerProfile(BGScrollingText, ['x', 'y', 'speed', 'size']));

-    var moreWays:BGScrollingText = new BGScrollingText(0, 160, 'HOT BLOODED IN MORE WAYS THAN ONE', FlxG.width, true, 43);
+    moreWays = new BGScrollingText(0, 160, 'HOT BLOODED IN MORE WAYS THAN ONE', FlxG.width, true, 43);
    moreWays.funnyColor = 0xFFFFF383;
    moreWays.speed = 6.8;
    grpTxtScrolls.add(moreWays);
@ -273,7 +347,7 @@ class FreeplayState extends MusicBeatSubState
        speed: 0.4,
      });

-    var funnyScroll:BGScrollingText = new BGScrollingText(0, 220, 'BOYFRIEND', FlxG.width / 2, false, 60);
+    funnyScroll = new BGScrollingText(0, 220, 'BOYFRIEND', FlxG.width / 2, false, 60);
    funnyScroll.funnyColor = 0xFFFF9963;
    funnyScroll.speed = -3.8;
    grpTxtScrolls.add(funnyScroll);
@ -286,7 +360,7 @@ class FreeplayState extends MusicBeatSubState
        wait: 0
      });

-    var txtNuts:BGScrollingText = new BGScrollingText(0, 285, 'PROTECT YO NUTS', FlxG.width / 2, true, 43);
+    txtNuts = new BGScrollingText(0, 285, 'PROTECT YO NUTS', FlxG.width / 2, true, 43);
    txtNuts.speed = 3.5;
    grpTxtScrolls.add(txtNuts);
    exitMovers.set([txtNuts],
@ -295,7 +369,7 @@ class FreeplayState extends MusicBeatSubState
        speed: 0.4,
      });

-    var funnyScroll2:BGScrollingText = new BGScrollingText(0, 335, 'BOYFRIEND', FlxG.width / 2, false, 60);
+    funnyScroll2 = new BGScrollingText(0, 335, 'BOYFRIEND', FlxG.width / 2, false, 60);
    funnyScroll2.funnyColor = 0xFFFF9963;
    funnyScroll2.speed = -3.8;
    grpTxtScrolls.add(funnyScroll2);
@ -306,7 +380,7 @@ class FreeplayState extends MusicBeatSubState
        speed: 0.5,
      });

-    var moreWays2:BGScrollingText = new BGScrollingText(0, 397, 'HOT BLOODED IN MORE WAYS THAN ONE', FlxG.width, true, 43);
+    moreWays2 = new BGScrollingText(0, 397, 'HOT BLOODED IN MORE WAYS THAN ONE', FlxG.width, true, 43);
    moreWays2.funnyColor = 0xFFFFF383;
    moreWays2.speed = 6.8;
    grpTxtScrolls.add(moreWays2);
@ -317,7 +391,7 @@ class FreeplayState extends MusicBeatSubState
        speed: 0.4
      });

-    var funnyScroll3:BGScrollingText = new BGScrollingText(0, orangeBackShit.y + 10, 'BOYFRIEND', FlxG.width / 2, 60);
+    funnyScroll3 = new BGScrollingText(0, orangeBackShit.y + 10, 'BOYFRIEND', FlxG.width / 2, 60);
    funnyScroll3.funnyColor = 0xFFFEA400;
    funnyScroll3.speed = -3.8;
    grpTxtScrolls.add(funnyScroll3);
@ -328,6 +402,24 @@ class FreeplayState extends MusicBeatSubState
        speed: 0.3
      });

+    backingTextYeah = new FlxAtlasSprite(640, 370, Paths.animateAtlas("freeplay/backing-text-yeah"),
+      {
+        FrameRate: 24.0,
+        Reversed: false,
+        // ?OnComplete:Void -> Void,
+        ShowPivot: false,
+        Antialiasing: true,
+        ScrollFactor: new FlxPoint(1, 1),
+      });
+
+    add(backingTextYeah);
+
+    cardGlow = new FlxSprite(-30, -30).loadGraphic(Paths.image('freeplay/cardGlow'));
+    cardGlow.blend = BlendMode.ADD;
+    cardGlow.visible = false;
+
+    add(cardGlow);
+
    dj = new DJBoyfriend(640, 366);
    exitMovers.set([dj],
      {
@ -340,7 +432,7 @@ class FreeplayState extends MusicBeatSubState

    add(dj);

-    var bgDad:FlxSprite = new FlxSprite(pinkBack.width * 0.75, 0).loadGraphic(Paths.image('freeplay/freeplayBGdad'));
+    bgDad = new FlxSprite(pinkBack.width * 0.75, 0).loadGraphic(Paths.image('freeplay/freeplayBGdad'));
    bgDad.setGraphicSize(0, FlxG.height);
    bgDad.updateHitbox();
    bgDad.shader = new AngleMask();
@ -357,10 +449,14 @@ class FreeplayState extends MusicBeatSubState
      });

    add(bgDad);
-    FlxTween.tween(blackOverlayBullshitLOLXD, {x: pinkBack.width * 0.75}, 0.7, {ease: FlxEase.quintOut});
+    FlxTween.tween(blackOverlayBullshitLOLXD, {x: pinkBack.width * 0.76}, 0.7, {ease: FlxEase.quintOut});

    blackOverlayBullshitLOLXD.shader = bgDad.shader;

+    rankBg = new FunkinSprite(0, 0);
+    rankBg.makeSolidColor(FlxG.width, FlxG.height, 0xD3000000);
+    add(rankBg);
+
    grpSongs = new FlxTypedGroup<Alphabet>();
    add(grpSongs);

@ -503,10 +599,6 @@ class FreeplayState extends MusicBeatSubState

      albumRoll.playIntro();

-      new FlxTimer().start(0.75, function(_) {
-        // albumRoll.showTitle();
-      });
-
      FlxTween.tween(grpDifficulties, {x: 90}, 0.6, {ease: FlxEase.quartOut});

      diffSelLeft.visible = true;
@ -542,18 +634,40 @@ class FreeplayState extends MusicBeatSubState
      orangeBackShit.visible = true;
      alsoOrangeLOL.visible = true;
      grpTxtScrolls.visible = true;
+
+      cardGlow.visible = true;
+      FlxTween.tween(cardGlow, {alpha: 0, "scale.x": 1.2, "scale.y": 1.2}, 0.45, {ease: FlxEase.sineOut});
+
+      if (fromResultsParams != null)
+      {
+        rankAnimStart(fromResultsParams);
+      }
    });

    generateSongList(null, false);

    // dedicated camera for the state so we don't need to fuk around with camera scrolls from the mainmenu / elsewhere
-    var funnyCam:FunkinCamera = new FunkinCamera('freeplayFunny', 0, 0, FlxG.width, FlxG.height);
+    funnyCam = new FunkinCamera('freeplayFunny', 0, 0, FlxG.width, FlxG.height);
    funnyCam.bgColor = FlxColor.TRANSPARENT;
    FlxG.cameras.add(funnyCam, false);

+    rankVignette = new FlxSprite(0, 0).loadGraphic(Paths.image('freeplay/rankVignette'));
+    rankVignette.scale.set(2, 2);
+    rankVignette.updateHitbox();
+    rankVignette.blend = BlendMode.ADD;
+    // rankVignette.cameras = [rankCamera];
+    add(rankVignette);
+    rankVignette.alpha = 0;
+
    forEach(function(bs) {
      bs.cameras = [funnyCam];
    });
+
+    rankCamera = new FunkinCamera('rankCamera', 0, 0, FlxG.width, FlxG.height);
+    rankCamera.bgColor = FlxColor.TRANSPARENT;
+    FlxG.cameras.add(rankCamera, false);
+    rankBg.cameras = [rankCamera];
+    rankBg.alpha = 0;
  }

  var currentFilter:SongFilter = null;
@ -598,8 +712,15 @@ class FreeplayState extends MusicBeatSubState
    // If curSelected is 0, the result will be null and fall back to the rememberedSongId.
    rememberedSongId = grpCapsules.members[curSelected]?.songData?.songId ?? rememberedSongId;

+    if (fromResultsParams != null)
+    {
+      rememberedSongId = fromResultsParams.songId;
+      rememberedDifficulty = fromResultsParams.difficultyId;
+    }
+
    for (cap in grpCapsules.members)
    {
+      cap.songText.resetText();
      cap.kill();
    }

@ -617,9 +738,11 @@ class FreeplayState extends MusicBeatSubState
    };
    randomCapsule.y = randomCapsule.intendedY(0) + 10;
    randomCapsule.targetPos.x = randomCapsule.x;
-    randomCapsule.alpha = 0.5;
+    randomCapsule.alpha = 0;
    randomCapsule.songText.visible = false;
    randomCapsule.favIcon.visible = false;
+    randomCapsule.ranking.visible = false;
+    randomCapsule.blurredRanking.visible = false;
    randomCapsule.initJumpIn(0, force);
    randomCapsule.hsvShader = hsvShader;
    grpCapsules.add(randomCapsule);
@ -642,8 +765,12 @@ class FreeplayState extends MusicBeatSubState
      funnyMenu.favIcon.visible = tempSongs[i].isFav;
      funnyMenu.hsvShader = hsvShader;

+      funnyMenu.newText.animation.curAnim.curFrame = 45 - ((i * 4) % 45);
+
      funnyMenu.forcePosition();

+      funnyMenu.checkClip();
+
      grpCapsules.add(funnyMenu);
    }

@ -697,6 +824,215 @@ class FreeplayState extends MusicBeatSubState
    return songsToFilter;
  }

+  function rankAnimStart(fromResults:Null<FromResultsParams>):Void
+  {
+    busy = true;
+
+    dj.fistPump();
+    // rankCamera.fade(FlxColor.BLACK, 0.5, true);
+    rankCamera.fade(0xFF000000, 0.5, true, null, true);
+    if (FlxG.sound.music != null) FlxG.sound.music.volume = 0;
+    rankBg.alpha = 1;
+
+    originalPos.x = grpCapsules.members[curSelected].x;
+    originalPos.y = grpCapsules.members[curSelected].y;
+
+    grpCapsules.members[curSelected].ranking.alpha = 0;
+    grpCapsules.members[curSelected].blurredRanking.alpha = 0;
+
+    rankCamera.zoom = 1.85;
+    FlxTween.tween(rankCamera, {"zoom": 1.8}, 0.6, {ease: FlxEase.sineIn});
+
+    funnyCam.zoom = 1.15;
+    FlxTween.tween(funnyCam, {"zoom": 1.1}, 0.6, {ease: FlxEase.sineIn});
+
+    grpCapsules.members[curSelected].cameras = [rankCamera];
+    grpCapsules.members[curSelected].targetPos.set((FlxG.width / 2) - (grpCapsules.members[curSelected].width / 2),
+      (FlxG.height / 2) - (grpCapsules.members[curSelected].height / 2));
+
+    new FlxTimer().start(0.5, _ -> {
+      grpCapsules.members[curSelected].doLerp = false;
+      rankDisplayNew(fromResults);
+    });
+  }
+
+  function rankDisplayNew(fromResults:Null<FromResultsParams>):Void
+  {
+    grpCapsules.members[curSelected].ranking.alpha = 1;
+    grpCapsules.members[curSelected].blurredRanking.alpha = 1;
+
+    grpCapsules.members[curSelected].ranking.scale.set(20, 20);
+    grpCapsules.members[curSelected].blurredRanking.scale.set(20, 20);
+
+    grpCapsules.members[curSelected].ranking.animation.play(fromResults.newRank.getFreeplayRankIconAsset(), true);
+    // grpCapsules.members[curSelected].ranking.animation.curAnim.name, true);
+
+    FlxTween.tween(grpCapsules.members[curSelected].ranking, {"scale.x": 1, "scale.y": 1}, 0.1);
+
+    grpCapsules.members[curSelected].blurredRanking.animation.play(fromResults.newRank.getFreeplayRankIconAsset(), true);
+    FlxTween.tween(grpCapsules.members[curSelected].blurredRanking, {"scale.x": 1, "scale.y": 1}, 0.1);
+
+    new FlxTimer().start(0.1, _ -> {
+      trace(grpCapsules.members[curSelected].ranking.rank);
+      switch (fromResultsParams?.newRank)
+      {
+        case SHIT:
+          FunkinSound.playOnce(Paths.sound('ranks/rankinbad'));
+        case PERFECT:
+          FunkinSound.playOnce(Paths.sound('ranks/rankinperfect'));
+        case PERFECT_GOLD:
+          FunkinSound.playOnce(Paths.sound('ranks/rankinperfect'));
+        default:
+          FunkinSound.playOnce(Paths.sound('ranks/rankinnormal'));
+      }
+      rankCamera.zoom = 1.3;
+      // FlxTween.tween(rankCamera, {"zoom": 1.4}, 0.3, {ease: FlxEase.elasticOut});
+
+      FlxTween.tween(rankCamera, {"zoom": 1.5}, 0.3, {ease: FlxEase.backInOut});
+
+      grpCapsules.members[curSelected].x -= 10;
+      grpCapsules.members[curSelected].y -= 20;
+
+      FlxTween.tween(funnyCam, {"zoom": 1.05}, 0.3, {ease: FlxEase.elasticOut});
+
+      grpCapsules.members[curSelected].capsule.angle = -3;
+      FlxTween.tween(grpCapsules.members[curSelected].capsule, {angle: 0}, 0.5, {ease: FlxEase.backOut});
+
+      IntervalShake.shake(grpCapsules.members[curSelected].capsule, 0.3, 1 / 30, 0.1, 0, FlxEase.quadOut);
+    });
+
+    new FlxTimer().start(0.4, _ -> {
+      FlxTween.tween(funnyCam, {"zoom": 1}, 0.8, {ease: FlxEase.sineIn});
+      FlxTween.tween(rankCamera, {"zoom": 1.2}, 0.8, {ease: FlxEase.backIn});
+      // IntervalShake.shake(grpCapsules.members[curSelected], 0.8 + 0.5, 1 / 24, 0, 2, FlxEase.quadIn);
+      FlxTween.tween(grpCapsules.members[curSelected], {x: originalPos.x - 7, y: originalPos.y - 80}, 0.8 + 0.5, {ease: FlxEase.quartIn});
+    });
+
+    new FlxTimer().start(0.6, _ -> {
+      rankAnimSlam(fromResults);
+      // IntervalShake.shake(grpCapsules.members[curSelected].capsule, 0.3, 1 / 30, 0, 0.3, FlxEase.quartIn);
+    });
+  }
+
+  function rankAnimSlam(fromResultsParams:Null<FromResultsParams>)
+  {
+    // FlxTween.tween(rankCamera, {"zoom": 1.9}, 0.5, {ease: FlxEase.backOut});
+    FlxTween.tween(rankBg, {alpha: 0}, 0.5, {ease: FlxEase.expoIn});
+
+    // FlxTween.tween(grpCapsules.members[curSelected], {angle: 5}, 0.5, {ease: FlxEase.backIn});
+
+    switch (fromResultsParams?.newRank)
+    {
+      case SHIT:
+        FunkinSound.playOnce(Paths.sound('ranks/loss'));
+      case GOOD:
+        FunkinSound.playOnce(Paths.sound('ranks/good'));
+      case GREAT:
+        FunkinSound.playOnce(Paths.sound('ranks/great'));
+      case EXCELLENT:
+        FunkinSound.playOnce(Paths.sound('ranks/excellent'));
+      case PERFECT:
+        FunkinSound.playOnce(Paths.sound('ranks/perfect'));
+      case PERFECT_GOLD:
+        FunkinSound.playOnce(Paths.sound('ranks/perfect'));
+      default:
+        FunkinSound.playOnce(Paths.sound('ranks/loss'));
+    }
+
+    FlxTween.tween(grpCapsules.members[curSelected], {"targetPos.x": originalPos.x, "targetPos.y": originalPos.y}, 0.5, {ease: FlxEase.expoOut});
+    new FlxTimer().start(0.5, _ -> {
+      funnyCam.shake(0.0045, 0.35);
+
+      if (fromResultsParams?.newRank == SHIT)
+      {
+        dj.pumpFistBad();
+      }
+      else
+      {
+        dj.pumpFist();
+      }
+
+      rankCamera.zoom = 0.8;
+      funnyCam.zoom = 0.8;
+      FlxTween.tween(rankCamera, {"zoom": 1}, 1, {ease: FlxEase.elasticOut});
+      FlxTween.tween(funnyCam, {"zoom": 1}, 0.8, {ease: FlxEase.elasticOut});
+
+      for (index => capsule in grpCapsules.members)
+      {
+        var distFromSelected:Float = Math.abs(index - curSelected) - 1;
+
+        if (distFromSelected < 5)
+        {
+          if (index == curSelected)
+          {
+            FlxTween.cancelTweensOf(capsule);
+            // capsule.targetPos.x += 50;
+            capsule.fadeAnim();
+
+            rankVignette.color = capsule.getTrailColor();
+            rankVignette.alpha = 1;
+            FlxTween.tween(rankVignette, {alpha: 0}, 0.6, {ease: FlxEase.expoOut});
+
+            capsule.doLerp = false;
+            capsule.setPosition(originalPos.x, originalPos.y);
+            IntervalShake.shake(capsule, 0.6, 1 / 24, 0.12, 0, FlxEase.quadOut, function(_) {
+              capsule.doLerp = true;
+              capsule.cameras = [funnyCam];
+
+              // NOW we can interact with the menu
+              busy = false;
+            }, null);
+
+            // FlxTween.tween(capsule, {"targetPos.x": capsule.targetPos.x - 50}, 0.6,
+            //   {
+            //     ease: FlxEase.backInOut,
+            //     onComplete: function(_) {
+            //       capsule.cameras = [funnyCam];
+            //     }
+            //   });
+            FlxTween.tween(capsule, {angle: 0}, 0.5, {ease: FlxEase.backOut});
+          }
+          if (index > curSelected)
+          {
+            // capsule.color = FlxColor.RED;
+            new FlxTimer().start(distFromSelected / 20, _ -> {
+              capsule.doLerp = false;
+
+              capsule.capsule.angle = FlxG.random.float(-10 + (distFromSelected * 2), 10 - (distFromSelected * 2));
+              FlxTween.tween(capsule.capsule, {angle: 0}, 0.5, {ease: FlxEase.backOut});
+
+              IntervalShake.shake(capsule, 0.6, 1 / 24, 0.12 / (distFromSelected + 1), 0, FlxEase.quadOut, function(_) {
+                capsule.doLerp = true;
+              });
+            });
+          }
+
+          if (index < curSelected)
+          {
+            // capsule.color = FlxColor.BLUE;
+            new FlxTimer().start(distFromSelected / 20, _ -> {
+              capsule.doLerp = false;
+
+              capsule.capsule.angle = FlxG.random.float(-10 + (distFromSelected * 2), 10 - (distFromSelected * 2));
+              FlxTween.tween(capsule.capsule, {angle: 0}, 0.5, {ease: FlxEase.backOut});
+
+              IntervalShake.shake(capsule, 0.6, 1 / 24, 0.12 / (distFromSelected + 1), 0, FlxEase.quadOut, function(_) {
+                capsule.doLerp = true;
+              });
+            });
+          }
+        }
+
+        index += 1;
+      }
+    });
+
+    new FlxTimer().start(2, _ -> {
+      // dj.fistPump();
+      FlxG.sound.music.fadeIn(4.0, 0.0, 1.0);
+    });
+  }
+
  var touchY:Float = 0;
  var touchX:Float = 0;
  var dxTouch:Float = 0;
@ -711,20 +1047,63 @@ class FreeplayState extends MusicBeatSubState
  var spamTimer:Float = 0;
  var spamming:Bool = false;

-  var busy:Bool = false; // Set to true once the user has pressed enter to select a song.
+  /**
+   * If true, disable interaction with the interface.
+   */
+  var busy:Bool = false;
+
+  var originalPos:FlxPoint = new FlxPoint();

  override function update(elapsed:Float):Void
  {
    super.update(elapsed);

+    #if debug
+    if (FlxG.keys.justPressed.T)
+    {
+      rankAnimStart(fromResultsParams);
+    }
+
+    if (FlxG.keys.justPressed.H)
+    {
+      rankDisplayNew(fromResultsParams);
+    }
+
+    if (FlxG.keys.justPressed.G)
+    {
+      rankAnimSlam(fromResultsParams);
+    }
+
+    if (FlxG.keys.justPressed.I)
+    {
+      confirmTextGlow.y -= 1;
+      trace(confirmTextGlow.x, confirmTextGlow.y);
+    }
+    if (FlxG.keys.justPressed.J)
+    {
+      confirmTextGlow.x -= 1;
+      trace(confirmTextGlow.x, confirmTextGlow.y);
+    }
+    if (FlxG.keys.justPressed.L)
+    {
+      confirmTextGlow.x += 1;
+      trace(confirmTextGlow.x, confirmTextGlow.y);
+    }
+    if (FlxG.keys.justPressed.K)
+    {
+      confirmTextGlow.y += 1;
+      trace(confirmTextGlow.x, confirmTextGlow.y);
+    }
+    #end
+
    if (FlxG.keys.justPressed.F)
    {
      var targetSong = grpCapsules.members[curSelected]?.songData;
      if (targetSong != null)
      {
        var realShit:Int = curSelected;
-        targetSong.isFav = !targetSong.isFav;
-        if (targetSong.isFav)
+        var isFav = targetSong.toggleFavorite();
+        if (isFav)
        {
          FlxTween.tween(grpCapsules.members[realShit], {angle: 360}, 0.4,
            {
@ -1036,7 +1415,7 @@ class FreeplayState extends MusicBeatSubState
    {
      var songScore:SaveScoreData = Save.instance.getSongScore(grpCapsules.members[curSelected].songData.songId, currentDifficulty);
      intendedScore = songScore?.score ?? 0;
-      intendedCompletion = songScore?.accuracy ?? 0.0;
+      intendedCompletion = songScore == null ? 0.0 : ((songScore.tallies.sick + songScore.tallies.good) / songScore.tallies.totalNotes);
      rememberedDifficulty = currentDifficulty;
    }
    else
@ -1101,6 +1480,9 @@ class FreeplayState extends MusicBeatSubState
      albumRoll.albumId = newAlbumId;
      albumRoll.skipIntro();
    }
+
+    // Set difficulty star count.
+    albumRoll.setDifficultyStars(daSong?.difficultyRating);
  }

  // Clears the cache of songs, frees up memory, they' ll have to be loaded in later tho function clearDaCache(actualSongTho:String)
@ -1174,6 +1556,42 @@ class FreeplayState extends MusicBeatSubState
    FunkinSound.playOnce(Paths.sound('confirmMenu'));
    dj.confirm();

+    grpCapsules.members[curSelected].songText.flickerText();
+
+    // FlxTween.color(bgDad, 0.33, 0xFFFFFFFF, 0xFF555555, {ease: FlxEase.quadOut});
+    FlxTween.color(pinkBack, 0.33, 0xFFFFD0D5, 0xFF171831, {ease: FlxEase.quadOut});
+    orangeBackShit.visible = false;
+    alsoOrangeLOL.visible = false;
+
+    confirmGlow.visible = true;
+    confirmGlow2.visible = true;
+
+    backingTextYeah.anim.play("BF back card confirm raw", false, false, 0);
+    confirmGlow2.alpha = 0;
+    confirmGlow.alpha = 0;
+
+    FlxTween.tween(confirmGlow2, {alpha: 0.5}, 0.33,
+      {
+        ease: FlxEase.quadOut,
+        onComplete: function(_) {
+          confirmGlow2.alpha = 0.6;
+          confirmGlow.alpha = 1;
+          confirmTextGlow.visible = true;
+          confirmTextGlow.alpha = 1;
+          FlxTween.tween(confirmTextGlow, {alpha: 0.4}, 0.5);
+          FlxTween.tween(confirmGlow, {alpha: 0}, 0.5);
+        }
+      });
+
+    // confirmGlow
+
+    moreWays.visible = false;
+    funnyScroll.visible = false;
+    txtNuts.visible = false;
+    funnyScroll2.visible = false;
+    moreWays2.visible = false;
+    funnyScroll3.visible = false;
+
    new FlxTimer().start(1, function(tmr:FlxTimer) {
      Paths.setCurrentLevel(cap.songData.levelId);
      LoadingState.loadPlayState(
@ -1231,7 +1649,7 @@ class FreeplayState extends MusicBeatSubState
    {
      var songScore:SaveScoreData = Save.instance.getSongScore(daSongCapsule.songData.songId, currentDifficulty);
      intendedScore = songScore?.score ?? 0;
-      intendedCompletion = songScore?.accuracy ?? 0.0;
+      intendedCompletion = songScore == null ? 0.0 : ((songScore.tallies.sick + songScore.tallies.good) / songScore.tallies.totalNotes);
      diffIdsCurrent = daSongCapsule.songData.songDifficulties;
      rememberedSongId = daSongCapsule.songData.songId;
      changeDiff();
@ -1272,23 +1690,24 @@ class FreeplayState extends MusicBeatSubState
      }
      else
      {
-        // TODO: Stream the instrumental of the selected song?
-        var didReplace:Bool = FunkinSound.playMusic('freakyMenu',
+        var potentiallyErect:String = (currentDifficulty == "erect") || (currentDifficulty == "nightmare") ? "-erect" : "";
+        FunkinSound.playMusic(daSongCapsule.songData.songId,
          {
            startingVolume: 0.0,
            overrideExisting: true,
-            restartTrack: false
+            restartTrack: false,
+            pathsFunction: INST,
+            suffix: potentiallyErect,
+            partialParams:
+              {
+                loadPartial: true,
+                start: 0.05,
+                end: 0.25
+              },
+            onLoad: function() {
+              FlxG.sound.music.fadeIn(2, 0, 0.4);
+            }
          });
-        if (didReplace)
-        {
-          FunkinSound.playMusic('freakyMenu',
-            {
-              startingVolume: 0.0,
-              overrideExisting: true,
-              restartTrack: false
-            });
-          FlxG.sound.music.fadeIn(2, 0, 0.8);
-        }
      }
      grpCapsules.members[curSelected].selected = true;
    }
@ -1412,11 +1831,15 @@ class FreeplaySongData

  public var songName(default, null):String = '';
  public var songCharacter(default, null):String = '';
-  public var songRating(default, null):Int = 0;
+  public var songStartingBpm(default, null):Float = 0;
+  public var difficultyRating(default, null):Int = 0;
  public var albumId(default, null):Null<String> = null;

  public var currentDifficulty(default, set):String = Constants.DEFAULT_DIFFICULTY;
-  public var displayedVariations(default, null):Array<String> = [Constants.DEFAULT_VARIATION];
+
+  public var scoringRank:Null<ScoringRank> = null;
+
+  var displayedVariations:Array<String> = [Constants.DEFAULT_VARIATION];

  function set_currentDifficulty(value:String):String
  {
@ -1432,11 +1855,32 @@ class FreeplaySongData
    this.levelId = levelId;
    this.songId = songId;
    this.song = song;
+
+    this.isFav = Save.instance.isSongFavorited(songId);
+
    if (displayedVariations != null) this.displayedVariations = displayedVariations;

    updateValues(displayedVariations);
  }

+  /**
+   * Toggle whether or not the song is favorited, then flush to save data.
+   * @return Whether or not the song is now favorited.
+   */
+  public function toggleFavorite():Bool
+  {
+    isFav = !isFav;
+    if (isFav)
+    {
+      Save.instance.favoriteSong(this.songId);
+    }
+    else
+    {
+      Save.instance.unfavoriteSong(this.songId);
+    }
+    return isFav;
+  }
+
  function updateValues(variations:Array<String>):Void
  {
    this.songDifficulties = song.listDifficulties(variations, false, false);
@ -1444,9 +1888,10 @@ class FreeplaySongData

    var songDifficulty:SongDifficulty = song.getDifficulty(currentDifficulty, variations);
    if (songDifficulty == null) return;
+    this.songStartingBpm = songDifficulty.getStartingBPM();
    this.songName = songDifficulty.songName;
    this.songCharacter = songDifficulty.characters.opponent;
-    this.songRating = songDifficulty.difficultyRating;
+    this.difficultyRating = songDifficulty.difficultyRating;
    if (songDifficulty.album == null)
    {
      FlxG.log.warn('No album for: ${songDifficulty.songName}');
@ -1456,6 +1901,8 @@ class FreeplaySongData
    {
      this.albumId = songDifficulty.album;
    }
+
+    this.scoringRank = Save.instance.getSongRank(songId, currentDifficulty);
  }
 }

--- a/source/funkin/ui/freeplay/SongMenuItem.hx
+++ b/source/funkin/ui/freeplay/SongMenuItem.hx
@ -14,6 +14,14 @@ import flixel.text.FlxText;
 import flixel.util.FlxTimer;
 import funkin.util.MathUtil;
 import funkin.graphics.shaders.Grayscale;
+import funkin.graphics.shaders.GaussianBlurShader;
+import openfl.display.BlendMode;
+import funkin.graphics.FunkinSprite;
+import flixel.tweens.FlxEase;
+import flixel.tweens.FlxTween;
+import flixel.addons.effects.FlxTrail;
+import funkin.play.scoring.Scoring.ScoringRank;
+import flixel.util.FlxColor;

 class SongMenuItem extends FlxSpriteGroup
 {
@ -31,9 +39,10 @@ class SongMenuItem extends FlxSpriteGroup

  public var songText:CapsuleText;
  public var favIcon:FlxSprite;
-  public var ranking:FlxSprite;
+  public var ranking:FreeplayRank;
+  public var blurredRanking:FreeplayRank;

-  var ranks:Array<String> = ["fail", "average", "great", "excellent", "perfect"];
+  var ranks:Array<String> = ["fail", "average", "great", "excellent", "perfect", "perfectsick"];

  public var targetPos:FlxPoint = new FlxPoint();
  public var doLerp:Bool = false;
@ -47,6 +56,20 @@ class SongMenuItem extends FlxSpriteGroup
  public var hsvShader(default, set):HSVShader;

  // var diffRatingSprite:FlxSprite;
+  public var bpmText:FlxSprite;
+  public var difficultyText:FlxSprite;
+  public var weekType:FlxSprite;
+
+  public var newText:FlxSprite;
+
+  // public var weekType:FlxSprite;
+  public var bigNumbers:Array<CapsuleNumber> = [];
+
+  public var smallNumbers:Array<CapsuleNumber> = [];
+
+  public var weekNumbers:Array<CapsuleNumber> = [];
+
+  var impactThing:FunkinSprite;

  public function new(x:Float, y:Float)
  {
@ -59,12 +82,61 @@ class SongMenuItem extends FlxSpriteGroup
    // capsule.animation
    add(capsule);

+    bpmText = new FlxSprite(144, 87).loadGraphic(Paths.image('freeplay/freeplayCapsule/bpmtext'));
+    bpmText.setGraphicSize(Std.int(bpmText.width * 0.9));
+    add(bpmText);
+
+    difficultyText = new FlxSprite(414, 87).loadGraphic(Paths.image('freeplay/freeplayCapsule/difficultytext'));
+    difficultyText.setGraphicSize(Std.int(difficultyText.width * 0.9));
+    add(difficultyText);
+
+    weekType = new FlxSprite(291, 87);
+    weekType.frames = Paths.getSparrowAtlas('freeplay/freeplayCapsule/weektypes');
+
+    weekType.animation.addByPrefix('WEEK', 'WEEK text instance 1', 24, false);
+    weekType.animation.addByPrefix('WEEKEND', 'WEEKEND text instance 1', 24, false);
+
+    weekType.setGraphicSize(Std.int(weekType.width * 0.9));
+    add(weekType);
+
+    newText = new FlxSprite(454, 9);
+    newText.frames = Paths.getSparrowAtlas('freeplay/freeplayCapsule/new');
+    newText.animation.addByPrefix('newAnim', 'NEW notif', 24, true);
+    newText.animation.play('newAnim', true);
+    newText.setGraphicSize(Std.int(newText.width * 0.9));
+
+    newText.visible = false;
+
+    add(newText);
+
+    // var debugNumber2:CapsuleNumber = new CapsuleNumber(0, 0, true, 2);
+    // add(debugNumber2);
+
+    for (i in 0...2)
+    {
+      var bigNumber:CapsuleNumber = new CapsuleNumber(466 + (i * 30), 32, true, 0);
+      add(bigNumber);
+
+      bigNumbers.push(bigNumber);
+    }
+
+    for (i in 0...3)
+    {
+      var smallNumber:CapsuleNumber = new CapsuleNumber(185 + (i * 11), 88.5, false, 0);
+      add(smallNumber);
+
+      smallNumbers.push(smallNumber);
+    }
+
    // doesn't get added, simply is here to help with visibility of things for the pop in!
    grpHide = new FlxGroup();

-    var rank:String = FlxG.random.getObject(ranks);
+    ranking = new FreeplayRank(420, 41);
+    add(ranking);

-    ranking = new FlxSprite(capsule.width * 0.84, 30);
+    blurredRanking = new FreeplayRank(ranking.x, ranking.y);
+    blurredRanking.shader = new GaussianBlurShader(1);
+    add(blurredRanking);
    // ranking.loadGraphic(Paths.image('freeplay/ranks/' + rank));
    // ranking.scale.x = ranking.scale.y = realScaled;
    // ranking.alpha = 0.75;
@ -73,11 +145,11 @@ class SongMenuItem extends FlxSpriteGroup
    // add(ranking);
    // grpHide.add(ranking);

-    switch (rank)
-    {
-      case 'perfect':
-        ranking.x -= 10;
-    }
+    // switch (rank)
+    // {
+    //   case 'perfect':
+    //     ranking.x -= 10;
+    // }

    grayscaleShader = new Grayscale(1);

@ -93,7 +165,7 @@ class SongMenuItem extends FlxSpriteGroup
    grpHide.add(songText);

    // TODO: Use value from metadata instead of random.
-    updateDifficultyRating(FlxG.random.int(0, 15));
+    updateDifficultyRating(FlxG.random.int(0, 20));

    pixelIcon = new FlxSprite(160, 35);

@ -103,25 +175,224 @@ class SongMenuItem extends FlxSpriteGroup
    add(pixelIcon);
    grpHide.add(pixelIcon);

-    favIcon = new FlxSprite(400, 40);
+    favIcon = new FlxSprite(380, 40);
    favIcon.frames = Paths.getSparrowAtlas('freeplay/favHeart');
    favIcon.animation.addByPrefix('fav', 'favorite heart', 24, false);
    favIcon.animation.play('fav');
    favIcon.setGraphicSize(50, 50);
    favIcon.visible = false;
+    favIcon.blend = BlendMode.ADD;
    add(favIcon);
-    // grpHide.add(favIcon);
+
+    var weekNumber:CapsuleNumber = new CapsuleNumber(355, 88.5, false, 0);
+    add(weekNumber);
+
+    weekNumbers.push(weekNumber);

    setVisibleGrp(false);
  }

+  // no way to grab weeks rn, so this needs to be done :/
+  // negative values mean weekends
+  function checkWeek(name:String):Void
+  {
+    // trace(name);
+    var weekNum:Int = 0;
+    switch (name)
+    {
+      case 'bopeebo' | 'fresh' | 'dadbattle':
+        weekNum = 1;
+      case 'spookeez' | 'south' | 'monster':
+        weekNum = 2;
+      case 'pico' | 'philly-nice' | 'blammed':
+        weekNum = 3;
+      case "satin-panties" | 'high' | 'milf':
+        weekNum = 4;
+      case "cocoa" | 'eggnog' | 'winter-horrorland':
+        weekNum = 5;
+      case 'senpai' | 'roses' | 'thorns':
+        weekNum = 6;
+      case 'ugh' | 'guns' | 'stress':
+        weekNum = 7;
+      case 'darnell' | 'lit-up' | '2hot' | 'blazin':
+        weekNum = -1;
+      default:
+        weekNum = 0;
+    }
+
+    weekNumbers[0].digit = Std.int(Math.abs(weekNum));
+
+    if (weekNum == 0)
+    {
+      weekType.visible = false;
+      weekNumbers[0].visible = false;
+    }
+    else
+    {
+      weekType.visible = true;
+      weekNumbers[0].visible = true;
+    }
+    if (weekNum > 0)
+    {
+      weekType.animation.play('WEEK', true);
+    }
+    else
+    {
+      weekType.animation.play('WEEKEND', true);
+      weekNumbers[0].offset.x -= 35;
+    }
+  }
+
+  // 255, 27 normal
+  // 220, 27 favourited
+  public function checkClip():Void
+  {
+    var clipSize:Int = 290;
+    var clipType:Int = 0;
+
+    if (ranking.visible == true) clipType += 1;
+    if (favIcon.visible == true) clipType += 1;
+    switch (clipType)
+    {
+      case 2:
+        clipSize = 220;
+      case 1:
+        clipSize = 255;
+    }
+    songText.clipWidth = clipSize;
+  }
+
+  function updateBPM(newBPM:Int):Void
+  {
+    var shiftX:Float = 191;
+    var tempShift:Float = 0;
+
+    if (Math.floor(newBPM / 100) == 1)
+    {
+      shiftX = 186;
+    }
+
+    for (i in 0...smallNumbers.length)
+    {
+      smallNumbers[i].x = this.x + (shiftX + (i * 11));
+      switch (i)
+      {
+        case 0:
+          if (newBPM < 100)
+          {
+            smallNumbers[i].digit = 0;
+          }
+          else
+          {
+            smallNumbers[i].digit = Math.floor(newBPM / 100) % 10;
+          }
+
+        case 1:
+          if (newBPM < 10)
+          {
+            smallNumbers[i].digit = 0;
+          }
+          else
+          {
+            smallNumbers[i].digit = Math.floor(newBPM / 10) % 10;
+
+            if (Math.floor(newBPM / 10) % 10 == 1) tempShift = -4;
+          }
+        case 2:
+          smallNumbers[i].digit = newBPM % 10;
+        default:
+          trace('why the fuck is this being called');
+      }
+      smallNumbers[i].x += tempShift;
+    }
+    // diffRatingSprite.loadGraphic(Paths.image('freeplay/diffRatings/diff${ratingPadded}'));
+    // diffRatingSprite.visible = false;
+  }
+
+  var evilTrail:FlxTrail;
+
+  public function fadeAnim()
+  {
+    impactThing = new FunkinSprite(0, 0);
+    impactThing.frames = capsule.frames;
+    impactThing.frame = capsule.frame;
+    impactThing.updateHitbox();
+    // impactThing.x = capsule.x;
+    // impactThing.y = capsule.y;
+    // picoFade.stamp(this, 0, 0);
+    impactThing.alpha = 0;
+    impactThing.zIndex = capsule.zIndex - 3;
+    add(impactThing);
+    FlxTween.tween(impactThing.scale, {x: 2.5, y: 2.5}, 0.5);
+    // FlxTween.tween(impactThing, {alpha: 0}, 0.5);
+
+    evilTrail = new FlxTrail(impactThing, null, 15, 2, 0.01, 0.069);
+    evilTrail.blend = BlendMode.ADD;
+    evilTrail.zIndex = capsule.zIndex - 5;
+    FlxTween.tween(evilTrail, {alpha: 0}, 0.6,
+      {
+        ease: FlxEase.quadOut,
+        onComplete: function(_) {
+          remove(evilTrail);
+        }
+      });
+    add(evilTrail);
+
+    switch (ranking.rank)
+    {
+      case SHIT:
+        evilTrail.color = 0xFF6044FF;
+      case GOOD:
+        evilTrail.color = 0xFFEF8764;
+      case GREAT:
+        evilTrail.color = 0xFFEAF6FF;
+      case EXCELLENT:
+        evilTrail.color = 0xFFFDCB42;
+      case PERFECT:
+        evilTrail.color = 0xFFFF58B4;
+      case PERFECT_GOLD:
+        evilTrail.color = 0xFFFFB619;
+    }
+  }
+
+  public function getTrailColor():FlxColor
+  {
+    return evilTrail.color;
+  }
+
  function updateDifficultyRating(newRating:Int):Void
  {
    var ratingPadded:String = newRating < 10 ? '0$newRating' : '$newRating';
+
+    for (i in 0...bigNumbers.length)
+    {
+      switch (i)
+      {
+        case 0:
+          if (newRating > 10)
+          {
+            bigNumbers[i].digit = 0;
+          }
+          else
+          {
+            bigNumbers[i].digit = Math.floor(newRating / 10);
+          }
+        case 1:
+          bigNumbers[i].digit = newRating % 10;
+        default:
+          trace('why the fuck is this being called');
+      }
+    }
    // diffRatingSprite.loadGraphic(Paths.image('freeplay/diffRatings/diff${ratingPadded}'));
    // diffRatingSprite.visible = false;
  }

+  function updateScoringRank(newRank:Null<ScoringRank>):Void
+  {
+    this.ranking.rank = newRank;
+    this.blurredRanking.rank = newRank;
+  }
+
  function set_hsvShader(value:HSVShader):HSVShader
  {
    this.hsvShader = value;
@ -168,9 +439,13 @@ class SongMenuItem extends FlxSpriteGroup
    songText.text = songData?.songName ?? 'Random';
    // Update capsule character.
    if (songData?.songCharacter != null) setCharacter(songData.songCharacter);
-    updateDifficultyRating(songData?.songRating ?? 0);
+    updateBPM(Std.int(songData?.songStartingBpm) ?? 0);
+    updateDifficultyRating(songData?.difficultyRating ?? 0);
+    updateScoringRank(songData?.scoringRank);
    // Update opacity, offsets, etc.
    updateSelected();
+
+    checkWeek(songData?.songId);
  }

  /**
@ -289,6 +564,28 @@ class SongMenuItem extends FlxSpriteGroup

  override function update(elapsed:Float):Void
  {
+    if (impactThing != null) impactThing.angle = capsule.angle;
+
+    // if (FlxG.keys.justPressed.I)
+    // {
+    //   newText.y -= 1;
+    //   trace(this.x - newText.x, this.y - newText.y);
+    // }
+    // if (FlxG.keys.justPressed.J)
+    // {
+    //   newText.x -= 1;
+    //   trace(this.x - newText.x, this.y - newText.y);
+    // }
+    // if (FlxG.keys.justPressed.L)
+    // {
+    //   newText.x += 1;
+    //   trace(this.x - newText.x, this.y - newText.y);
+    // }
+    // if (FlxG.keys.justPressed.K)
+    // {
+    //   newText.y += 1;
+    //   trace(this.x - newText.x, this.y - newText.y);
+    // }
    if (doJumpIn)
    {
      frameInTicker += elapsed;
@ -358,5 +655,147 @@ class SongMenuItem extends FlxSpriteGroup
    capsule.animation.play(this.selected ? "selected" : "unselected");
    ranking.alpha = this.selected ? 1 : 0.7;
    ranking.color = this.selected ? 0xFFFFFFFF : 0xFFAAAAAA;
+
+    if (selected)
+    {
+      if (songText.tooLong == true) songText.initMove();
+    }
+    else
+    {
+      if (songText.tooLong == true) songText.resetText();
+    }
+  }
+}
+
+class FreeplayRank extends FlxSprite
+{
+  public var rank(default, set):Null<ScoringRank> = null;
+
+  function set_rank(val:Null<ScoringRank>):Null<ScoringRank>
+  {
+    rank = val;
+
+    if (rank == null)
+    {
+      this.visible = false;
+    }
+    else
+    {
+      this.visible = true;
+
+      animation.play(val.getFreeplayRankIconAsset(), true, false);
+
+      centerOffsets(false);
+
+      switch (val)
+      {
+        case SHIT:
+        // offset.x -= 1;
+        case GOOD:
+          // offset.x -= 1;
+          offset.y -= 8;
+        case GREAT:
+          // offset.x -= 1;
+          offset.y -= 8;
+        case EXCELLENT:
+        // offset.y += 5;
+        case PERFECT:
+        // offset.y += 5;
+        case PERFECT_GOLD:
+        // offset.y += 5;
+        default:
+          centerOffsets(false);
+      }
+      updateHitbox();
+    }
+
+    return rank = val;
+  }
+
+  public var baseX:Float = 0;
+  public var baseY:Float = 0;
+
+  public function new(x:Float, y:Float)
+  {
+    super(x, y);
+
+    frames = Paths.getSparrowAtlas('freeplay/rankbadges');
+
+    animation.addByPrefix('PERFECT', 'PERFECT rank0', 24, false);
+    animation.addByPrefix('EXCELLENT', 'EXCELLENT rank0', 24, false);
+    animation.addByPrefix('GOOD', 'GOOD rank0', 24, false);
+    animation.addByPrefix('PERFECTSICK', 'PERFECT rank GOLD', 24, false);
+    animation.addByPrefix('GREAT', 'GREAT rank0', 24, false);
+    animation.addByPrefix('LOSS', 'LOSS rank0', 24, false);
+
+    blend = BlendMode.ADD;
+
+    this.rank = null;
+
+    // setGraphicSize(Std.int(width * 0.9));
+    scale.set(0.9, 0.9);
+    updateHitbox();
+  }
+}
+
+class CapsuleNumber extends FlxSprite
+{
+  public var digit(default, set):Int = 0;
+
+  function set_digit(val):Int
+  {
+    animation.play(numToString[val], true, false, 0);
+
+    centerOffsets(false);
+
+    switch (val)
+    {
+      case 1:
+        offset.x -= 4;
+      case 3:
+        offset.x -= 1;
+
+      case 6:
+
+      case 4:
+      // offset.y += 5;
+      case 9:
+      // offset.y += 5;
+      default:
+        centerOffsets(false);
+    }
+    return val;
+  }
+
+  public var baseY:Float = 0;
+  public var baseX:Float = 0;
+
+  var numToString:Array<String> = ["ZERO", "ONE", "TWO", "THREE", "FOUR", "FIVE", "SIX", "SEVEN", "EIGHT", "NINE"];
+
+  public function new(x:Float, y:Float, big:Bool = false, ?initDigit:Int = 0)
+  {
+    super(x, y);
+
+    if (big)
+    {
+      frames = Paths.getSparrowAtlas('freeplay/freeplayCapsule/bignumbers');
+    }
+    else
+    {
+      frames = Paths.getSparrowAtlas('freeplay/freeplayCapsule/smallnumbers');
+    }
+
+    for (i in 0...10)
+    {
+      var stringNum:String = numToString[i];
+      animation.addByPrefix(stringNum, '$stringNum', 24, false);
+    }
+
+    this.digit = initDigit;
+
+    animation.play(numToString[initDigit], true);
+
+    setGraphicSize(Std.int(width * 0.9));
+    updateHitbox();
  }
 }
--- a/source/funkin/ui/mainmenu/MainMenuState.hx
+++ b/source/funkin/ui/mainmenu/MainMenuState.hx
@ -354,8 +354,7 @@ class MainMenuState extends MusicBeatState
              maxCombo: 0,
              totalNotesHit: 0,
              totalNotes: 0,
-            },
-          accuracy: 0,
+            }
        });
    }
    #end
--- a/source/funkin/ui/story/LevelProp.hx
+++ b/source/funkin/ui/story/LevelProp.hx
@ -11,11 +11,13 @@ class LevelProp extends Bopper
  function set_propData(value:LevelPropData):LevelPropData
  {
    // Only reset the prop if the asset path has changed.
-    if (propData == null || value?.assetPath != propData?.assetPath)
+    if (propData == null || !(thx.Dynamics.equals(value, propData)))
    {
-      this.visible = (value != null);
      this.propData = value;
+
+      this.visible = this.propData != null;
      danceEvery = this.propData?.danceEvery ?? 0;
+
      applyData();
    }

--- a/source/funkin/ui/story/StoryMenuState.hx
+++ b/source/funkin/ui/story/StoryMenuState.hx
@ -306,7 +306,7 @@ class StoryMenuState extends MusicBeatState
  {
    Conductor.instance.update();

-    highScoreLerp = Std.int(MathUtil.smoothLerp(highScoreLerp, highScore, elapsed, 0.5));
+    highScoreLerp = Std.int(MathUtil.smoothLerp(highScoreLerp, highScore, elapsed, 0.25));

    scoreText.text = 'LEVEL SCORE: ${Math.round(highScoreLerp)}';

--- a/source/funkin/ui/title/TitleState.hx
+++ b/source/funkin/ui/title/TitleState.hx
@ -124,7 +124,7 @@ class TitleState extends MusicBeatState

    persistentUpdate = true;

-    var bg:FunkinSprite = new FunkinSprite().makeSolidColor(FlxG.width, FlxG.height, FlxColor.BLACK);
+    var bg:FunkinSprite = new FunkinSprite(-1).makeSolidColor(FlxG.width + 2, FlxG.height, FlxColor.BLACK);
    bg.screenCenter();
    add(bg);

--- a/source/funkin/util/Constants.hx
+++ b/source/funkin/util/Constants.hx
@ -248,6 +248,11 @@ class Constants
   */
  public static final DEFAULT_ARTIST:String = 'Unknown';

+  /**
+   * The default charter for songs.
+   */
+  public static final DEFAULT_CHARTER:String = 'Unknown';
+
  /**
   * The default note style for songs.
   */
@ -455,6 +460,17 @@ class Constants
  public static final JUDGEMENT_BAD_COMBO_BREAK:Bool = true;
  public static final JUDGEMENT_SHIT_COMBO_BREAK:Bool = true;

+  // % Sick
+  public static final RANK_PERFECT_PLAT_THRESHOLD:Float = 1.0; // % Sick
+  public static final RANK_PERFECT_GOLD_THRESHOLD:Float = 0.85; // % Sick
+
+  // % Hit
+  public static final RANK_PERFECT_THRESHOLD:Float = 1.00;
+  public static final RANK_EXCELLENT_THRESHOLD:Float = 0.90;
+  public static final RANK_GREAT_THRESHOLD:Float = 0.80;
+  public static final RANK_GOOD_THRESHOLD:Float = 0.60;
+
+  // public static final RANK_SHIT_THRESHOLD:Float = 0.00;
  /**
   * FILE EXTENSIONS
   */
--- a/source/funkin/util/StructureUtil.hx
+++ b/source/funkin/util/StructureUtil.hx
@ -1,136 +0,0 @@
-package funkin.util;
-
-import funkin.util.tools.MapTools;
-import haxe.DynamicAccess;
-
-/**
- * Utilities for working with anonymous structures.
- */
-class StructureUtil
-{
-  /**
-   * Merge two structures, with the second overwriting the first.
-   * Performs a SHALLOW clone, where child structures are not merged.
-   * @param a The base structure.
-   * @param b The new structure.
-   * @return The merged structure.
-   */
-  public static function merge(a:Dynamic, b:Dynamic):Dynamic
-  {
-    var result:DynamicAccess<Dynamic> = Reflect.copy(a);
-
-    for (field in Reflect.fields(b))
-    {
-      result.set(field, Reflect.field(b, field));
-    }
-
-    return result;
-  }
-
-  public static function toMap(a:Dynamic):haxe.ds.Map<String, Dynamic>
-  {
-    var result:haxe.ds.Map<String, Dynamic> = [];
-
-    for (field in Reflect.fields(a))
-    {
-      result.set(field, Reflect.field(a, field));
-    }
-
-    return result;
-  }
-
-  public static function isMap(a:Dynamic):Bool
-  {
-    return Std.isOfType(a, haxe.Constraints.IMap);
-  }
-
-  public static function isObject(a:Dynamic):Bool
-  {
-    switch (Type.typeof(a))
-    {
-      case TObject:
-        return true;
-      default:
-        return false;
-    }
-  }
-
-  public static function isPrimitive(a:Dynamic):Bool
-  {
-    switch (Type.typeof(a))
-    {
-      case TInt | TFloat | TBool:
-        return true;
-      case TClass(c):
-        return false;
-      case TEnum(e):
-        return false;
-      case TObject:
-        return false;
-      case TFunction:
-        return false;
-      case TNull:
-        return true;
-      case TUnknown:
-        return false;
-      default:
-        return false;
-    }
-  }
-
-  /**
-   * Merge two structures, with the second overwriting the first.
-   * Performs a DEEP clone, where child structures are also merged recursively.
-   * @param a The base structure.
-   * @param b The new structure.
-   * @return The merged structure.
-   */
-  public static function deepMerge(a:Dynamic, b:Dynamic):Dynamic
-  {
-    if (a == null) return b;
-    if (b == null) return null;
-    if (isPrimitive(a) && isPrimitive(b)) return b;
-    if (isMap(b))
-    {
-      if (isMap(a))
-      {
-        return MapTools.merge(a, b);
-      }
-      else
-      {
-        return StructureUtil.toMap(a).merge(b);
-      }
-    }
-    if (!Reflect.isObject(a) || !Reflect.isObject(b)) return b;
-    if (Std.isOfType(b, haxe.ds.StringMap))
-    {
-      if (Std.isOfType(a, haxe.ds.StringMap))
-      {
-        return MapTools.merge(a, b);
-      }
-      else
-      {
-        return StructureUtil.toMap(a).merge(b);
-      }
-    }
-
-    var result:DynamicAccess<Dynamic> = Reflect.copy(a);
-
-    for (field in Reflect.fields(b))
-    {
-      if (Reflect.isObject(b))
-      {
-        // Note that isObject also returns true for class instances,
-        // but we just assume that's not a problem here.
-        result.set(field, deepMerge(Reflect.field(result, field), Reflect.field(b, field)));
-      }
-      else
-      {
-        // If we're here, b[field] is a primitive.
-        result.set(field, Reflect.field(b, field));
-      }
-    }
-
-    return result;
-  }
-}
--- a/source/funkin/util/VersionUtil.hx
+++ b/source/funkin/util/VersionUtil.hx
@ -32,6 +32,25 @@ class VersionUtil
    }
  }

+  public static function repairVersion(version:thx.semver.Version):thx.semver.Version
+  {
+    var versionData:thx.semver.Version.SemVer = version;
+
+    if (thx.Types.isAnonymousObject(versionData.version))
+    {
+      // This is bad! versionData.version should be an array!
+      versionData.version = [versionData.version[0], versionData.version[1], versionData.version[2]];
+
+      var fixedVersion:thx.semver.Version = versionData;
+      return fixedVersion;
+    }
+    else
+    {
+      // No need for repair.
+      return version;
+    }
+  }
+
  /**
   * Checks that a given verison number satisisfies a given version rule.
   * Version rule can be complex, e.g. "1.0.x" or ">=1.0.0,<1.1.0", or anything NPM supports.
--- a/source/funkin/util/macro/InlineMacro.hx
+++ b/source/funkin/util/macro/InlineMacro.hx
@ -23,7 +23,7 @@ class InlineMacro
    var fields:Array<haxe.macro.Expr.Field> = haxe.macro.Context.getBuildFields();

    // Find the field with the given name.
-    var targetField:Null<haxe.macro.Expr.Field> = fields.find(function(f) return f.name == field
+    var targetField:Null<haxe.macro.Expr.Field> = thx.Arrays.find(fields, function(f) return f.name == field
      && (MacroUtil.isFieldStatic(f) == isStatic));

    // If the field was not found, throw an error.
--- a/source/funkin/util/tools/ArrayTools.hx
+++ b/source/funkin/util/tools/ArrayTools.hx
@ -5,72 +5,6 @@ package funkin.util.tools;
 */
 class ArrayTools
 {
-  /**
-   * Returns a copy of the array with all duplicate elements removed.
-   * @param array The array to remove duplicates from.
-   * @return A copy of the array with all duplicate elements removed.
-   */
-  public static function unique<T>(array:Array<T>):Array<T>
-  {
-    var result:Array<T> = [];
-    for (element in array)
-    {
-      if (!result.contains(element))
-      {
-        result.push(element);
-      }
-    }
-    return result;
-  }
-
-  /**
-   * Returns a copy of the array with all `null` elements removed.
-   * @param array The array to remove `null` elements from.
-   * @return A copy of the array with all `null` elements removed.
-   */
-  public static function nonNull<T>(array:Array<Null<T>>):Array<T>
-  {
-    var result:Array<T> = [];
-    for (element in array)
-    {
-      if (element != null)
-      {
-        result.push(element);
-      }
-    }
-    return result;
-  }
-
-  /**
-   * Return the first element of the array that satisfies the predicate, or null if none do.
-   * @param input The array to search
-   * @param predicate The predicate to call
-   * @return The result
-   */
-  public static function find<T>(input:Array<T>, predicate:T->Bool):Null<T>
-  {
-    for (element in input)
-    {
-      if (predicate(element)) return element;
-    }
-    return null;
-  }
-
-  /**
-   * Return the index of the first element of the array that satisfies the predicate, or `-1` if none do.
-   * @param input The array to search
-   * @param predicate The predicate to call
-   * @return The index of the result
-   */
-  public static function findIndex<T>(input:Array<T>, predicate:T->Bool):Int
-  {
-    for (index in 0...input.length)
-    {
-      if (predicate(input[index])) return index;
-    }
-    return -1;
-  }
-
  /*
   * Push an element to the array if it is not already present.
   * @param input The array to push to
--- a/tests/unit/assets/shared/images/arrows.png
+++ b/tests/unit/assets/shared/images/arrows.png
--- a/tests/unit/assets/shared/images/arrows.xml
+++ b/tests/unit/assets/shared/images/arrows.xml
@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<TextureAtlas imagePath="arrows.png">
-	<SubTexture name="staticLeft0001" x="0" y="0" width="17" height="17" />
-	<SubTexture name="staticDown0001" x="17" y="0" width="17" height="17" />
-	<SubTexture name="staticUp0001" x="34" y="0" width="17" height="17" />
-	<SubTexture name="staticRight0001" x="51" y="0" width="17" height="17" />
-	<SubTexture name="noteLeft0001" x="0" y="17" width="17" height="17" />
-	<SubTexture name="noteDown0001" x="17" y="17" width="17" height="17" />
-	<SubTexture name="noteUp0001" x="34" y="17" width="17" height="17" />
-	<SubTexture name="noteRight0001" x="51" y="17" width="17" height="17" />
-	<SubTexture name="pressedLeft0001" x="0" y="17" width="17" height="17" />
-	<SubTexture name="pressedDown0001" x="17" y="17" width="17" height="17" />
-	<SubTexture name="pressedUp0001" x="34" y="17" width="17" height="17" />
-	<SubTexture name="pressedRight0001" x="51" y="17" width="17" height="17" />
-	<SubTexture name="pressedLeft0002" x="0" y="34" width="17" height="17" />
-	<SubTexture name="pressedDown0002" x="17" y="34" width="17" height="17" />
-	<SubTexture name="pressedUp0002" x="34" y="34" width="17" height="17" />
-	<SubTexture name="pressedRight0002" x="51" y="34" width="17" height="17" />
-	<SubTexture name="confirmLeft0001" x="0" y="51" width="17" height="17" />
-	<SubTexture name="confirmDown0001" x="17" y="51" width="17" height="17" />
-	<SubTexture name="confirmUp0001" x="34" y="51" width="17" height="17" />
-	<SubTexture name="confirmRight0001" x="51" y="51" width="17" height="17" />
-	<SubTexture name="confirmLeft0002" x="0" y="68" width="17" height="17" />
-	<SubTexture name="confirmDown0002" x="17" y="68" width="17" height="17" />
-	<SubTexture name="confirmUp0002" x="34" y="68" width="17" height="17" />
-	<SubTexture name="confirmRight0002" x="51" y="68" width="17" height="17" />
-</TextureAtlas>