Fixed sorting option and direction being flipped. Fixed errors when moving replays, causing the explorer not to update correctly. Added an icon for replays on explorer. Made replay sound play when invalidation is actually incorrect. Added extra cases for when the explorer is null.

Author: xLoadingx

ERRORMODS-ReplayMod-1.0.0/Mods/ReplayMod.dll

@@ -50,11 +50,9 @@ public class Validation : ValidationParameters
     public override bool DoValidation(string Input)
     {
         if (Enum.TryParse(typeof(ReplayExplorer.SortingType), Input, true, out _))
-        {
-            Main.ReplayError();
             return true;
-        }
 
+        Main.ReplayError();
         return false;
     }
 }
@@ -1537,7 +1535,7 @@ public void LoadReplayObjects()
         ReplaySettings.replayExplorerGO = replayExplorerGO;
 
         ReplayFiles.folderIcon = bundle.LoadAsset<Texture2D>("FolderIcon");
-        ReplayFiles.replayIcon = bundle.LoadAsset<Texture2D>("RenameIcon");
+        ReplayFiles.replayIcon = bundle.LoadAsset<Texture2D>("ReplayIcon");
 
         for (int i = 0; i <= 5; i++)
         {

src/Core/Main.cs

@@ -2,10 +2,10 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using ReplayMod.Core;
 using ReplayMod.Replay.Serialization;
 using ReplayMod.Replay.UI;
 using static UnityEngine.Mathf;
+using Main = ReplayMod.Core.Main;
 
 namespace ReplayMod.Replay.Files;
 
@@ -50,7 +50,7 @@ public ReplayExplorer(string root)
 
     public void Refresh()
     {
-        Enum.TryParse((string)Main.instance.ExplorerSorting.SavedValue, true, out SortingType sortingType);
+        Enum.TryParse((string)Main.instance.ExplorerSorting.Value, true, out SortingType sortingType);
         currentReplayEntries = GetEntries(sortingType);
 
         currentIndex = Clamp(currentIndex, -1, currentReplayEntries.Count - 1);
@@ -71,12 +71,26 @@ public List<Entry> GetEntries(SortingType sorting = SortingType.Date)
 
         var files = Directory
             .GetFiles(CurrentFolderPath, "*.replay")
-            .Select(file => new Entry
+            .Select(file =>
             {
-                Name = Path.GetFileNameWithoutExtension(file),
-                FullPath = file,
-                header = ReplayArchive.GetManifest(file),
-                IsFolder = false,
+                ReplaySerializer.ReplayHeader header;
+
+                try
+                {
+                    header = ReplayArchive.GetManifest(file);
+                }
+                catch
+                {
+                    return null;
+                }
+                
+                return new Entry
+                {
+                    Name = Path.GetFileNameWithoutExtension(file),
+                    FullPath = file,
+                    header = header,
+                    IsFolder = false
+                };
             })
             .ToList();
 
@@ -102,26 +116,29 @@ public List<Entry> GetEntries(SortingType sorting = SortingType.Date)
 
     private List<Entry> SortFiles(List<Entry> files, SortingType sorting)
     {
-        if ((bool)Main.instance.FavoritesFirst.SavedValue)
-            files = files.OrderByDescending(f => f.header.isFavorited).ToList();
+        IOrderedEnumerable<Entry> query =
+            (bool)Main.instance.FavoritesFirst.SavedValue
+                ? files.OrderByDescending(f => f.header?.isFavorited ?? false)
+                : files.OrderBy(f => 0);
 
-        var newFiles = sorting switch
+        query = sorting switch
         {
-            SortingType.Name => files.OrderBy(f => f.Name).ToList(),
-            SortingType.Date => files.OrderByDescending(f => File.GetLastWriteTimeUtc(f.FullPath)).ToList(),
-            SortingType.Duration => files.OrderByDescending(f => f.header.Duration).ToList(),
-            SortingType.Map => files.OrderBy(f => ReplayFormatting.GetMapName(header: f.header), StringComparer.OrdinalIgnoreCase).ToList(),
-            SortingType.PlayerCount => files.OrderByDescending(f => f.header.Players?.Length).ToList(),
-            SortingType.OpponentBP => files.OrderByDescending(f => f.header.Players
+            SortingType.Name => query.ThenBy(f => f.Name),
+            SortingType.Date => query.ThenByDescending(f => File.GetLastWriteTimeUtc(f.FullPath)),
+            SortingType.Duration => query.ThenByDescending(f => f.header?.Duration ?? 0),
+            SortingType.Map => query.ThenBy(f => ReplayFormatting.GetMapName(header: f.header), StringComparer.OrdinalIgnoreCase),
+            SortingType.PlayerCount => query.ThenByDescending(f => f.header?.Players?.Length ?? 0),
+            SortingType.OpponentBP => query.ThenByDescending(f => f.header?.Players
                 .Where(p => !p.IsLocal)
                 .Select(p => p.BattlePoints)
-                .DefaultIfEmpty(0).Max()
-            ).ToList(),
-
-            _ => files
+                .DefaultIfEmpty(0)
+                .Max()),
+            _ => query
         };
 
-        if ((bool)Main.instance.SortingDirection.SavedValue)
+        var newFiles = query.ToList();
+        
+        if ((bool)Main.instance.SortingDirection.Value)
             newFiles.Reverse();
 
         return newFiles;

src/Core/replayobjects

@@ -350,6 +350,9 @@ private static void SelectReplayFromExplorer()
 
     public static void ReloadReplays()
     {
+        if (ReplaySettings.replayExplorerGO == null)
+            return;
+        
         var previousGuid = currentHeader?.Guid;
 
         explorer.currentPage = 0;
@@ -438,7 +441,7 @@ IEnumerator ApplySizeDelta() {
 
             var icon = button.transform.GetChild(1).GetChild(3).GetComponent<MeshRenderer>();
             icon.material.SetTexture("_Texture", entry.IsFolder ? folderIcon : replayIcon);
-            icon.transform.localScale = Vector3.one * (entry.IsFolder ? 0.0522f : 0.0522f);
+            icon.transform.localScale = (entry.IsFolder ? Vector3.one * 0.0522f : new Vector3(0.0422f, 0.0402f, 0.0422f));
 
             if (!entry.IsFolder)
                 button.transform.GetChild(1).GetChild(7).gameObject.SetActive(entry.header.isFavorited);