Merge pull request #494 from FunkinCrew/freeplay-sorting-fixes

fix letter sort regex, and tiny LetterSort.hx cleanin

checkstyle.json

@@ -550,7 +550,8 @@
     {
       "props": {
         "policy": "onlySingle",
-        "allowException": true
+        "allowException": true,
+        "severity": "IGNORE"
       },
       "type": "StringLiteral"
     },

source/funkin/ui/freeplay/FreeplayState.hx

@@ -539,41 +539,14 @@ class FreeplayState extends MusicBeatSubState
    * Given the current filter, rebuild the current song list.
    *
    * @param filterStuff A filter to apply to the song list (regex, startswith, all, favorite)
-   * @param force
+   * @param force Whether the capsules should "jump" back in or not using their animation
    * @param onlyIfChanged Only apply the filter if the song list has changed
    */
   public function generateSongList(filterStuff:Null<SongFilter>, force:Bool = false, onlyIfChanged:Bool = true):Void
   {
     var tempSongs:Array<FreeplaySongData> = songs;
 
-    if (filterStuff != null)
+    if (filterStuff != null) tempSongs = sortSongs(tempSongs, filterStuff);
-    {
-      switch (filterStuff.filterType)
-      {
-        case REGEXP:
-          // filterStuff.filterData has a string with the first letter of the sorting range, and the second one
-          // this creates a filter to return all the songs that start with a letter between those two
-          var filterRegexp:EReg = new EReg('^[' + filterStuff.filterData + '].*', 'i');
-          tempSongs = tempSongs.filter(str -> {
-            if (str == null) return true; // Random
-            return filterRegexp.match(str.songName);
-          });
-        case STARTSWITH:
-          tempSongs = tempSongs.filter(str -> {
-            if (str == null) return true; // Random
-            return str.songName.toLowerCase().startsWith(filterStuff.filterData);
-          });
-        case ALL:
-        // no filter!
-        case FAVORITE:
-          tempSongs = tempSongs.filter(str -> {
-            if (str == null) return true; // Random
-            return str.isFav;
-          });
-        default:
-          // return all on default
-      }
-    }
 
     // Filter further by current selected difficulty.
     if (currentDifficulty != null)
@@ -651,6 +624,48 @@ class FreeplayState extends MusicBeatSubState
     changeDiff();
   }
 
+  /**
+   * Filters an array of songs based on a filter
+   * @param songsToFilter What data to use when filtering
+   * @param songFilter The filter to apply
+   * @return Array<FreeplaySongData>
+   */
+  public function sortSongs(songsToFilter:Array<FreeplaySongData>, songFilter:SongFilter):Array<FreeplaySongData>
+  {
+    switch (songFilter.filterType)
+    {
+      case REGEXP:
+        // filterStuff.filterData has a string with the first letter of the sorting range, and the second one
+        // this creates a filter to return all the songs that start with a letter between those two
+
+        // if filterData looks like "A-C", the regex should look something like this: ^[A-C].*
+        // to get every song that starts between A and C
+        var filterRegexp:EReg = new EReg('^[' + songFilter.filterData + '].*', 'i');
+        songsToFilter = songsToFilter.filter(str -> {
+          if (str == null) return true; // Random
+          return filterRegexp.match(str.songName);
+        });
+
+      case STARTSWITH:
+        // extra note: this is essentially a "search"
+
+        songsToFilter = songsToFilter.filter(str -> {
+          if (str == null) return true; // Random
+          return str.songName.toLowerCase().startsWith(songFilter.filterData);
+        });
+      case ALL:
+      // no filter!
+      case FAVORITE:
+        songsToFilter = songsToFilter.filter(str -> {
+          if (str == null) return true; // Random
+          return str.isFav;
+        });
+      default:
+        // return all on default
+    }
+    return songsToFilter;
+  }
+
   var touchY:Float = 0;
   var touchX:Float = 0;
   var dxTouch:Float = 0;

source/funkin/ui/freeplay/LetterSort.hx

@@ -39,7 +39,6 @@ class LetterSort extends FlxTypedSpriteGroup<FlxSprite>
       var letter:FreeplayLetter = new FreeplayLetter(i * 80, 0, i);
       letter.x += 50;
       letter.y += 50;
-      letter.ogY = y;
       // letter.visible = false;
       add(letter);
 
@@ -54,7 +53,7 @@ class LetterSort extends FlxTypedSpriteGroup<FlxSprite>
       // don't put the last seperator
       if (i == 4) continue;
 
-      var sep:FlxSprite = new FlxSprite((i * 80) + 55, 20).loadGraphic(Paths.image("freeplay/seperator"));
+      var sep:FlxSprite = new FlxSprite((i * 80) + 60, 20).loadGraphic(Paths.image("freeplay/seperator"));
       // sep.animation.play("seperator");
       sep.color = letter.color.getDarkened(darkness);
       add(sep);
@@ -70,7 +69,7 @@ class LetterSort extends FlxTypedSpriteGroup<FlxSprite>
     changeSelection(0);
   }
 
-  override function update(elapsed:Float)
+  override function update(elapsed:Float):Void
   {
     super.update(elapsed);
 
@@ -81,7 +80,27 @@ class LetterSort extends FlxTypedSpriteGroup<FlxSprite>
     }
   }
 
-  public function changeSelection(diff:Int = 0)
+  public function changeSelection(diff:Int = 0):Void
+  {
+    doLetterChangeAnims(diff);
+
+    var multiPosOrNeg:Float = diff > 0 ? 1 : -1;
+
+    // if we're moving left (diff < 0), we want control of the right arrow, and vice versa
+    var arrowToMove:FlxSprite = diff < 0 ? leftArrow : rightArrow;
+    arrowToMove.offset.x = 3 * multiPosOrNeg;
+
+    new FlxTimer().start(2 / 24, function(_) {
+      arrowToMove.offset.x = 0;
+    });
+  }
+
+  /**
+   * Buncho timers and stuff to move the letters and seperators
+   * Seperated out so we can call it again on letters with songs within them
+   * @param diff
+   */
+  function doLetterChangeAnims(diff:Int):Void
   {
     var ezTimer:Int->FlxSprite->Float->Void = function(frameNum:Int, spr:FlxSprite, offsetNum:Float) {
       new FlxTimer().start(frameNum / 24, function(_) {
@@ -91,148 +110,119 @@ class LetterSort extends FlxTypedSpriteGroup<FlxSprite>
 
     var positions:Array<Float> = [-10, -22, 2, 0];
 
-    if (diff < 0)
+    // if we're moving left, we want to move the positions the same amount, but negative direciton
+    var multiPosOrNeg:Float = diff > 0 ? 1 : -1;
+
+    for (sep in grpSeperators)
     {
-      for (sep in grpSeperators)
+      ezTimer(0, sep, positions[0] * multiPosOrNeg);
-      {
+      ezTimer(1, sep, positions[1] * multiPosOrNeg);
-        ezTimer(0, sep, positions[0]);
+      ezTimer(2, sep, positions[2] * multiPosOrNeg);
-        ezTimer(1, sep, positions[1]);
+      ezTimer(3, sep, positions[3] * multiPosOrNeg);
-        ezTimer(2, sep, positions[2]);
-        ezTimer(3, sep, positions[3]);
-      }
-
-      for (index => letter in letters)
-      {
-        letter.offset.x = positions[0];
-
-        new FlxTimer().start(1 / 24, function(_) {
-          letter.offset.x = positions[1];
-          if (index == 0) letter.visible = false;
-        });
-
-        new FlxTimer().start(2 / 24, function(_) {
-          letter.offset.x = positions[2];
-          if (index == 0.) letter.visible = true;
-        });
-
-        if (index == 2)
-        {
-          ezTimer(3, letter, 0);
-          // letter.offset.x = 0;
-          continue;
-        }
-
-        ezTimer(3, letter, positions[3]);
-      }
-
-      leftArrow.offset.x = 3;
-      new FlxTimer().start(2 / 24, function(_) {
-        leftArrow.offset.x = 0;
-      });
     }
-    else if (diff > 0)
+
+    for (index => letter in letters)
     {
-      for (sep in grpSeperators)
+      letter.offset.x = positions[0] * multiPosOrNeg;
-      {
-        ezTimer(0, sep, -positions[0]);
-        ezTimer(1, sep, -positions[1]);
-        ezTimer(2, sep, -positions[2]);
-        ezTimer(3, sep, -positions[3]);
-      }
-      // same timing and functions and shit as the left one... except to the right!!
 
-      for (index => letter in letters)
+      new FlxTimer().start(1 / 24, function(_) {
-      {
+        letter.offset.x = positions[1] * multiPosOrNeg;
-        letter.offset.x = -positions[0];
+        if (index == 0) letter.visible = false;
-
-        new FlxTimer().start(1 / 24, function(_) {
-          letter.offset.x = -positions[1];
-          if (index == 0) letter.visible = false;
-        });
-
-        new FlxTimer().start(2 / 24, function(_) {
-          letter.offset.x = -positions[2];
-          if (index == 0) letter.visible = true;
-        });
-
-        if (index == 2)
-        {
-          ezTimer(3, letter, 0);
-          // letter.offset.x = 0;
-          continue;
-        }
-
-        ezTimer(3, letter, -positions[3]);
-      }
-
-      rightArrow.offset.x = -3;
-      new FlxTimer().start(2 / 24, function(_) {
-        rightArrow.offset.x = 0;
       });
+
+      new FlxTimer().start(2 / 24, function(_) {
+        letter.offset.x = positions[2] * multiPosOrNeg;
+        if (index == 0.) letter.visible = true;
+      });
+
+      if (index == 2)
+      {
+        ezTimer(3, letter, 0);
+        // letter.offset.x = 0;
+        continue;
+      }
+
+      ezTimer(3, letter, positions[3] * multiPosOrNeg);
     }
 
     curSelection += diff;
-    if (curSelection < 0) curSelection = letters[0].arr.length - 1;
+    if (curSelection < 0) curSelection = letters[0].regexLetters.length - 1;
-    if (curSelection >= letters[0].arr.length) curSelection = 0;
+    if (curSelection >= letters[0].regexLetters.length) curSelection = 0;
 
     for (letter in letters)
       letter.changeLetter(diff, curSelection);
 
-    if (changeSelectionCallback != null) changeSelectionCallback(letters[2].arr[letters[2].curLetter]); // bullshit and long lol!
+    if (changeSelectionCallback != null) changeSelectionCallback(letters[2].regexLetters[letters[2].curLetter]); // bullshit and long lol!
   }
 }
 
+/**
+ * The actual FlxAtlasSprite for the letters, with their animation code stuff and regex stuff
+ */
 class FreeplayLetter extends FlxAtlasSprite
 {
-  public var arr:Array<String> = [];
+  /**
+   * A preformatted array of letter strings, for use when doing regex
+   * ex: ['A-B', 'C-D', 'E-H', 'I-L' ...]
+   */
+  public var regexLetters:Array<String> = [];
 
+  /**
+   * A preformatted array of the letters, for use when accessing symbol animation info
+   * ex: ['AB', 'CD', 'EH', 'IL' ...]
+   */
+  public var animLetters:Array<String> = [];
+
+  /**
+   * The current letter in the regexLetters array this FreeplayLetter is on
+   */
   public var curLetter:Int = 0;
 
-  public var ogY:Float = 0;
-
   public function new(x:Float, y:Float, ?letterInd:Int)
   {
     super(x, y, Paths.animateAtlas("freeplay/sortedLetters"));
-    // frames = Paths.getSparrowAtlas("freeplay/letterStuff");
-    // this.anim.play("AB");
-    // trace(this.anim.symbolDictionary);
 
-    var alphabet:String = "AB-CD-EH-I L-MN-OR-s-t-UZ";
+    // this is used for the regex
-    arr = alphabet.split("-");
+    // /^[OR].*/gi doesn't work for showing the song Pico, so now it's
-    arr.insert(0, "ALL");
+    // /^[O-R].*/gi ant it works for displaying Pico
-    arr.insert(0, "fav");
+    // https://regex101.com/r/bWFPfS/1
-    arr.insert(0, "#");
+    // we split by underscores, simply for nice lil convinience
+    var alphabet:String = 'A-B_C-D_E-H_I-L_M-N_O-R_S_T_U-Z';
+    regexLetters = alphabet.split('_');
+    regexLetters.insert(0, 'ALL');
+    regexLetters.insert(0, 'fav');
+    regexLetters.insert(0, '#');
 
-    // trace(arr);
+    // the symbols from flash don't have dashes, so we clean this up for use with animations
-
+    // (we don't need to re-export, rule of thumb is to accomodate files named in flash from dave
-    // for (str in arr)
+    //    until we get him programming classes (and since i cant find the .fla file....))
-    // {
+    animLetters = regexLetters.map(animLetter -> animLetter.replace('-', ''));
-    //   animation.addByPrefix(str, str + " "); // string followed by a space! intentional!
-    // }
-
-    // animation.addByPrefix("arrow", "mini arrow");
-    // animation.addByPrefix("seperator", "seperator");
 
     if (letterInd != null)
     {
-      this.anim.play(arr[letterInd] + " move");
+      this.anim.play(animLetters[letterInd] + " move");
       this.anim.pause();
       curLetter = letterInd;
     }
   }
 
-  public function changeLetter(diff:Int = 0, ?curSelection:Int)
+  /**
+   * Changes the letter graphic/anim, used in the LetterSort class above
+   * @param diff -1 or 1, to go left or right in the animation array
+   * @param curSelection what the current letter selection is, to play the bouncing anim if it matches the current letter
+   */
+  public function changeLetter(diff:Int = 0, ?curSelection:Int):Void
   {
     curLetter += diff;
 
-    if (curLetter < 0) curLetter = arr.length - 1;
+    if (curLetter < 0) curLetter = regexLetters.length - 1;
-    if (curLetter >= arr.length) curLetter = 0;
+    if (curLetter >= regexLetters.length) curLetter = 0;
 
-    var animName:String = arr[curLetter] + " move";
+    var animName:String = animLetters[curLetter] + ' move';
 
-    switch (arr[curLetter])
+    switch (animLetters[curLetter])
     {
-      case "I L":
+      case "IL":
         animName = "IL move";
       case "s":
         animName = "S move";