add support for partial cache invalidation (#335)

3 files changed, 202 insertions, 55 deletions

diff --git a/src/StardewModdingAPI/Constants.cs b/src/StardewModdingAPI/Constants.cs
index ee57be0f..e85d7e2b 100644
--- a/src/StardewModdingAPI/Constants.cs
+++ b/src/StardewModdingAPI/Constants.cs
@@ -11,6 +11,9 @@ using StardewModdingAPI.AssemblyRewriters.Rewriters.Wrappers;
 using StardewModdingAPI.Events;
 using StardewModdingAPI.Framework;
 using StardewValley;
+using StardewValley.BellsAndWhistles;
+using StardewValley.Objects;
+using StardewValley.Projectiles;
 
 namespace StardewModdingAPI
 {
@@ -99,7 +102,7 @@ namespace StardewModdingAPI
 
 
         /*********
-        ** Protected methods
+        ** Internal methods
         *********/
         /// <summary>Get metadata for mapping assemblies to the current platform.</summary>
         /// <param name="targetPlatform">The target game platform.</param>
@@ -220,6 +223,69 @@ namespace StardewModdingAPI
             };
         }
 
+        /// <summary>Get the game's static asset setters by (non-normalised) asset name.</summary>
+        /// <remarks>Derived from <see cref="Game1.LoadContent"/>.</remarks>
+        internal static IDictionary<string, Action<SContentManager, string>> GetCoreAssetSetters()
+        {
+            return new Dictionary<string, Action<SContentManager, string>>
+            {
+                // from Game1.loadContent
+                ["LooseSprites\\daybg"] = (content, key) => Game1.daybg = content.Load<Texture2D>(key),
+                ["LooseSprites\\daybg"] = (content, key) => Game1.daybg = content.Load<Texture2D>(key),
+                ["LooseSprites\\nightbg"] = (content, key) => Game1.nightbg = content.Load<Texture2D>(key),
+                ["Maps\\MenuTiles"] = (content, key) => Game1.menuTexture = content.Load<Texture2D>(key),
+                ["LooseSprites\\Lighting\\lantern"] = (content, key) => Game1.lantern = content.Load<Texture2D>(key),
+                ["LooseSprites\\Lighting\\windowLight"] = (content, key) => Game1.windowLight = content.Load<Texture2D>(key),
+                ["LooseSprites\\Lighting\\sconceLight"] = (content, key) => Game1.sconceLight = content.Load<Texture2D>(key),
+                ["LooseSprites\\Lighting\\greenLight"] = (content, key) => Game1.cauldronLight = content.Load<Texture2D>(key),
+                ["LooseSprites\\Lighting\\indoorWindowLight"] = (content, key) => Game1.indoorWindowLight = content.Load<Texture2D>(key),
+                ["LooseSprites\\shadow"] = (content, key) => Game1.shadowTexture = content.Load<Texture2D>(key),
+                ["LooseSprites\\Cursors"] = (content, key) => Game1.mouseCursors = content.Load<Texture2D>(key),
+                ["LooseSprites\\ControllerMaps"] = (content, key) => Game1.controllerMaps = content.Load<Texture2D>(key),
+                ["TileSheets\\animations"] = (content, key) => Game1.animations = content.Load<Texture2D>(key),
+                ["Data\\Achievements"] = (content, key) => Game1.achievements = content.Load<Dictionary<int, string>>(key),
+                ["Data\\NPCGiftTastes"] = (content, key) => Game1.NPCGiftTastes = content.Load<Dictionary<string, string>>(key),
+                ["Fonts\\SpriteFont1"] = (content, key) => Game1.dialogueFont = content.Load<SpriteFont>(key),
+                ["Fonts\\SmallFont"] = (content, key) => Game1.smallFont = content.Load<SpriteFont>(key),
+                ["Fonts\\tinyFont"] = (content, key) => Game1.tinyFont = content.Load<SpriteFont>(key),
+                ["Fonts\\tinyFontBorder"] = (content, key) => Game1.tinyFontBorder = content.Load<SpriteFont>(key),
+                ["Maps\\springobjects"] = (content, key) => Game1.objectSpriteSheet = content.Load<Texture2D>(key),
+                ["TileSheets\\crops"] = (content, key) => Game1.cropSpriteSheet = content.Load<Texture2D>(key),
+                ["TileSheets\\emotes"] = (content, key) => Game1.emoteSpriteSheet = content.Load<Texture2D>(key),
+                ["TileSheets\\debris"] = (content, key) => Game1.debrisSpriteSheet = content.Load<Texture2D>(key),
+                ["TileSheets\\Craftables"] = (content, key) => Game1.bigCraftableSpriteSheet = content.Load<Texture2D>(key),
+                ["TileSheets\\rain"] = (content, key) => Game1.rainTexture = content.Load<Texture2D>(key),
+                ["TileSheets\\BuffsIcons"] = (content, key) => Game1.buffsIcons = content.Load<Texture2D>(key),
+                ["Data\\ObjectInformation"] = (content, key) => Game1.objectInformation = content.Load<Dictionary<int, string>>(key),
+                ["Data\\BigCraftablesInformation"] = (content, key) => Game1.bigCraftablesInformation = content.Load<Dictionary<int, string>>(key),
+                ["Characters\\Farmer\\hairstyles"] = (content, key) => FarmerRenderer.hairStylesTexture = content.Load<Texture2D>(key),
+                ["Characters\\Farmer\\shirts"] = (content, key) => FarmerRenderer.shirtsTexture = content.Load<Texture2D>(key),
+                ["Characters\\Farmer\\hats"] = (content, key) => FarmerRenderer.hatsTexture = content.Load<Texture2D>(key),
+                ["Characters\\Farmer\\accessories"] = (content, key) => FarmerRenderer.accessoriesTexture = content.Load<Texture2D>(key),
+                ["TileSheets\\furniture"] = (content, key) => Furniture.furnitureTexture = content.Load<Texture2D>(key),
+                ["LooseSprites\\font_bold"] = (content, key) => SpriteText.spriteTexture = content.Load<Texture2D>(key),
+                ["LooseSprites\\font_colored"] = (content, key) => SpriteText.coloredTexture = content.Load<Texture2D>(key),
+                ["TileSheets\\weapons"] = (content, key) => Tool.weaponsTexture = content.Load<Texture2D>(key),
+                ["TileSheets\\Projectiles"] = (content, key) => Projectile.projectileSheet = content.Load<Texture2D>(key),
+
+                // from Farmer constructor
+                ["Characters\\Farmer\\farmer_base"] = (content, key) =>
+                {
+                    if (Game1.player != null && Game1.player.isMale)
+                        Game1.player.FarmerRenderer = new FarmerRenderer(content.Load<Texture2D>(key));
+                },
+                ["Characters\\Farmer\\farmer_girl_base"] = (content, key) =>
+                {
+                    if (Game1.player != null && !Game1.player.isMale)
+                        Game1.player.FarmerRenderer = new FarmerRenderer(content.Load<Texture2D>(key));
+                }
+            };
+        }
+
+
+        /*********
+        ** Private methods
+        *********/
         /// <summary>Get the name of a save directory for the current player.</summary>
         private static string GetSaveFolderName()
         {
diff --git a/src/StardewModdingAPI/Framework/SContentManager.cs b/src/StardewModdingAPI/Framework/SContentManager.cs
index 669b0e7a..e6b0cac2 100644
--- a/src/StardewModdingAPI/Framework/SContentManager.cs
+++ b/src/StardewModdingAPI/Framework/SContentManager.cs
@@ -5,14 +5,10 @@ using System.IO;
 using System.Linq;
 using Microsoft.Xna.Framework;
 using Microsoft.Xna.Framework.Content;
-using Microsoft.Xna.Framework.Graphics;
 using StardewModdingAPI.AssemblyRewriters;
 using StardewModdingAPI.Framework.Content;
 using StardewModdingAPI.Framework.Reflection;
 using StardewValley;
-using StardewValley.BellsAndWhistles;
-using StardewValley.Objects;
-using StardewValley.Projectiles;
 
 namespace StardewModdingAPI.Framework
 {
@@ -40,6 +36,12 @@ namespace StardewModdingAPI.Framework
         /// <summary>The private <see cref="LocalizedContentManager"/> method which generates the locale portion of an asset name.</summary>
         private readonly IPrivateMethod GetKeyLocale;
 
+        /// <summary>The language codes used in asset keys.</summary>
+        private IDictionary<string, LanguageCode> KeyLocales;
+
+        /// <summary>The game's static asset setters by normalised asset name.</summary>
+        private readonly IDictionary<string, Action> CoreAssetSetters;
+
 
         /*********
         ** Accessors
@@ -86,6 +88,48 @@ namespace StardewModdingAPI.Framework
             }
             else
                 this.NormaliseAssetNameForPlatform = key => key.Replace('\\', '/'); // based on MonoGame's ContentManager.Load<T> logic
+
+            // get asset key locales
+            this.KeyLocales = this.GetKeyLocales(reflection);
+            this.CoreAssetSetters = this.GetCoreAssetSetters();
+
+        }
+
+        /// <summary>Get methods to reload core game assets by normalised key.</summary>
+        private IDictionary<string, Action> GetCoreAssetSetters()
+        {
+            return Constants.GetCoreAssetSetters()
+                .ToDictionary<KeyValuePair<string, Action<SContentManager, string>>, string, Action>(
+                    p => this.NormaliseAssetName(p.Key),
+                    p => () => p.Value(this, p.Key)
+                );
+        }
+
+        /// <summary>Get the locale codes (like <c>ja-JP</c>) used in asset keys.</summary>
+        /// <param name="reflection">Simplifies access to private game code.</param>
+        private IDictionary<string, LanguageCode> GetKeyLocales(Reflector reflection)
+        {
+            // get the private code field directly to avoid changed-code logic
+            IPrivateField<LanguageCode> codeField = reflection.GetPrivateField<LanguageCode>(typeof(LocalizedContentManager), "_currentLangCode");
+
+            // remember previous settings
+            LanguageCode previousCode = codeField.GetValue();
+            string previousOverride = this.LanguageCodeOverride;
+
+            // create locale => code map
+            IDictionary<string, LanguageCode> map = new Dictionary<string, LanguageCode>(StringComparer.InvariantCultureIgnoreCase);
+            this.LanguageCodeOverride = null;
+            foreach (LanguageCode code in Enum.GetValues(typeof(LanguageCode)))
+            {
+                codeField.SetValue(code);
+                map[this.GetKeyLocale.Invoke<string>()] = code;
+            }
+
+            // restore previous settings
+            codeField.SetValue(previousCode);
+            this.LanguageCodeOverride = previousOverride;
+
+            return map;
         }
 
         /// <summary>Normalise path separators in a file path. For asset keys, see <see cref="NormaliseAssetName"/> instead.</summary>
@@ -159,54 +203,55 @@ namespace StardewModdingAPI.Framework
             return this.GetKeyLocale.Invoke<string>();
         }
 
+        /// <summary>Get the cached asset keys.</summary>
+        public IEnumerable<string> GetAssetKeys()
+        {
+            IEnumerable<string> GetAllAssetKeys()
+            {
+                foreach (string cacheKey in this.Cache.Keys)
+                {
+                    this.ParseCacheKey(cacheKey, out string assetKey, out string _);
+                    yield return assetKey;
+                }
+            }
+
+            return GetAllAssetKeys().Distinct();
+        }
+
         /// <summary>Reset the asset cache and reload the game's static assets.</summary>
+        /// <param name="predicate">Matches the asset keys to invalidate.</param>
         /// <remarks>This implementation is derived from <see cref="Game1.LoadContent"/>.</remarks>
-        public void Reset()
+        public void InvalidateCache(Func<string, bool> predicate)
         {
-            this.Monitor.Log("Resetting asset cache...", LogLevel.Trace);
-            this.Cache.Clear();
-
-            // from Game1.LoadContent
-            Game1.daybg = this.Load<Texture2D>("LooseSprites\\daybg");
-            Game1.nightbg = this.Load<Texture2D>("LooseSprites\\nightbg");
-            Game1.menuTexture = this.Load<Texture2D>("Maps\\MenuTiles");
-            Game1.lantern = this.Load<Texture2D>("LooseSprites\\Lighting\\lantern");
-            Game1.windowLight = this.Load<Texture2D>("LooseSprites\\Lighting\\windowLight");
-            Game1.sconceLight = this.Load<Texture2D>("LooseSprites\\Lighting\\sconceLight");
-            Game1.cauldronLight = this.Load<Texture2D>("LooseSprites\\Lighting\\greenLight");
-            Game1.indoorWindowLight = this.Load<Texture2D>("LooseSprites\\Lighting\\indoorWindowLight");
-            Game1.shadowTexture = this.Load<Texture2D>("LooseSprites\\shadow");
-            Game1.mouseCursors = this.Load<Texture2D>("LooseSprites\\Cursors");
-            Game1.controllerMaps = this.Load<Texture2D>("LooseSprites\\ControllerMaps");
-            Game1.animations = this.Load<Texture2D>("TileSheets\\animations");
-            Game1.achievements = this.Load<Dictionary<int, string>>("Data\\Achievements");
-            Game1.NPCGiftTastes = this.Load<Dictionary<string, string>>("Data\\NPCGiftTastes");
-            Game1.dialogueFont = this.Load<SpriteFont>("Fonts\\SpriteFont1");
-            Game1.smallFont = this.Load<SpriteFont>("Fonts\\SmallFont");
-            Game1.tinyFont = this.Load<SpriteFont>("Fonts\\tinyFont");
-            Game1.tinyFontBorder = this.Load<SpriteFont>("Fonts\\tinyFontBorder");
-            Game1.objectSpriteSheet = this.Load<Texture2D>("Maps\\springobjects");
-            Game1.cropSpriteSheet = this.Load<Texture2D>("TileSheets\\crops");
-            Game1.emoteSpriteSheet = this.Load<Texture2D>("TileSheets\\emotes");
-            Game1.debrisSpriteSheet = this.Load<Texture2D>("TileSheets\\debris");
-            Game1.bigCraftableSpriteSheet = this.Load<Texture2D>("TileSheets\\Craftables");
-            Game1.rainTexture = this.Load<Texture2D>("TileSheets\\rain");
-            Game1.buffsIcons = this.Load<Texture2D>("TileSheets\\BuffsIcons");
-            Game1.objectInformation = this.Load<Dictionary<int, string>>("Data\\ObjectInformation");
-            Game1.bigCraftablesInformation = this.Load<Dictionary<int, string>>("Data\\BigCraftablesInformation");
-            FarmerRenderer.hairStylesTexture = this.Load<Texture2D>("Characters\\Farmer\\hairstyles");
-            FarmerRenderer.shirtsTexture = this.Load<Texture2D>("Characters\\Farmer\\shirts");
-            FarmerRenderer.hatsTexture = this.Load<Texture2D>("Characters\\Farmer\\hats");
-            FarmerRenderer.accessoriesTexture = this.Load<Texture2D>("Characters\\Farmer\\accessories");
-            Furniture.furnitureTexture = this.Load<Texture2D>("TileSheets\\furniture");
-            SpriteText.spriteTexture = this.Load<Texture2D>("LooseSprites\\font_bold");
-            SpriteText.coloredTexture = this.Load<Texture2D>("LooseSprites\\font_colored");
-            Tool.weaponsTexture = this.Load<Texture2D>("TileSheets\\weapons");
-            Projectile.projectileSheet = this.Load<Texture2D>("TileSheets\\Projectiles");
-
-            // from Farmer constructor
-            if (Game1.player != null)
-                Game1.player.FarmerRenderer = new FarmerRenderer(this.Load<Texture2D>("Characters\\Farmer\\farmer_" + (Game1.player.isMale ? "" : "girl_") + "base"));
+            // find matching asset keys
+            HashSet<string> purgeCacheKeys = new HashSet<string>(StringComparer.InvariantCultureIgnoreCase);
+            HashSet<string> purgeAssetKeys = new HashSet<string>(StringComparer.InvariantCultureIgnoreCase);
+            foreach (string cacheKey in this.Cache.Keys)
+            {
+                this.ParseCacheKey(cacheKey, out string assetKey, out string localeCode);
+                if (predicate(assetKey))
+                {
+                    purgeAssetKeys.Add(assetKey);
+                    purgeCacheKeys.Add(cacheKey);
+                }
+            }
+
+            // purge from cache
+            foreach (string key in purgeCacheKeys)
+                this.Cache.Remove(key);
+
+            // reload core game assets
+            int reloaded = 0;
+            foreach (string key in purgeAssetKeys)
+            {
+                if (this.CoreAssetSetters.TryGetValue(key, out Action reloadAsset))
+                {
+                    reloadAsset();
+                    reloaded++;
+                }
+            }
+
+            this.Monitor.Log($"Invalidated {purgeCacheKeys.Count} cache entries for {purgeAssetKeys.Count} asset keys: {string.Join(", ", purgeCacheKeys.OrderBy(p => p, StringComparer.InvariantCultureIgnoreCase))}. Reloaded {reloaded} core assets.", LogLevel.Trace);
         }
 
 
@@ -221,6 +266,33 @@ namespace StardewModdingAPI.Framework
                 || this.Cache.ContainsKey($"{normalisedAssetName}.{this.GetKeyLocale.Invoke<string>()}"); // translated asset
         }
 
+        /// <summary>Parse a cache key into its component parts.</summary>
+        /// <param name="cacheKey">The input cache key.</param>
+        /// <param name="assetKey">The original asset key.</param>
+        /// <param name="localeCode">The asset locale code (or <c>null</c> if not localised).</param>
+        private void ParseCacheKey(string cacheKey, out string assetKey, out string localeCode)
+        {
+            // handle localised key
+            if (!string.IsNullOrWhiteSpace(cacheKey))
+            {
+                int lastSepIndex = cacheKey.LastIndexOf(".", StringComparison.InvariantCulture);
+                if (lastSepIndex >= 0)
+                {
+                    string suffix = cacheKey.Substring(lastSepIndex + 1, cacheKey.Length - lastSepIndex - 1);
+                    if (this.KeyLocales.ContainsKey(suffix))
+                    {
+                        assetKey = cacheKey.Substring(0, lastSepIndex);
+                        localeCode = cacheKey.Substring(lastSepIndex + 1, cacheKey.Length - lastSepIndex - 1);
+                        return;
+                    }
+                }
+            }
+
+            // handle simple key
+            assetKey = cacheKey;
+            localeCode = null;
+        }
+
         /// <summary>Load the initial asset from the registered <see cref="Loaders"/>.</summary>
         /// <param name="info">The basic asset metadata.</param>
         /// <returns>Returns the loaded asset metadata, or <c>null</c> if no loader matched.</returns>
@@ -365,7 +437,8 @@ namespace StardewModdingAPI.Framework
             // can't know which assets are meant to be disposed. Here we remove current assets from
             // the cache, but don't dispose them to avoid crashing any code that still references
             // them. The garbage collector will eventually clean up any unused assets.
-            this.Reset();
+            this.Monitor.Log("Content manager disposed, resetting cache.", LogLevel.Trace);
+            this.InvalidateCache(p => true);
         }
     }
 }
diff --git a/src/StardewModdingAPI/Program.cs b/src/StardewModdingAPI/Program.cs
index 50ab4e25..56c56431 100644
--- a/src/StardewModdingAPI/Program.cs
+++ b/src/StardewModdingAPI/Program.cs
@@ -796,7 +796,7 @@ namespace StardewModdingAPI
                     if (this.DeprecationManager.IsVirtualMethodImplemented(mod.GetType(), typeof(Mod), nameof(Mod.Entry), new[] { typeof(object[]) }))
                         deprecationWarnings.Add(() => this.DeprecationManager.Warn(metadata.DisplayName, $"{nameof(Mod)}.{nameof(Mod.Entry)}(object[]) instead of {nameof(Mod)}.{nameof(Mod.Entry)}({nameof(IModHelper)})", "1.0", DeprecationLevel.PendingRemoval));
 #else
-                    if (!this.DeprecationManager.IsVirtualMethodImplemented(mod.GetType(), typeof(Mod), nameof(Mod.Entry), new[] {typeof(IModHelper)}))
+                    if (!this.DeprecationManager.IsVirtualMethodImplemented(mod.GetType(), typeof(Mod), nameof(Mod.Entry), new[] { typeof(IModHelper) }))
                         this.Monitor.Log($"{metadata.DisplayName} doesn't implement Entry() and may not work correctly.", LogLevel.Error);
 #endif
                 }
@@ -812,19 +812,27 @@ namespace StardewModdingAPI
             {
                 if (metadata.Mod.Helper.Content is ContentHelper helper)
                 {
+                    // TODO: optimise by only reloading assets the new editors/loaders can intercept
                     helper.ObservableAssetEditors.CollectionChanged += (sender, e) =>
                     {
                         if (e.NewItems.Count > 0)
-                            this.ContentManager.Reset();
+                        {
+                            this.Monitor.Log("Detected new asset editor, resetting cache...", LogLevel.Trace);
+                            this.ContentManager.InvalidateCache(p => true);
+                        }
                     };
                     helper.ObservableAssetLoaders.CollectionChanged += (sender, e) =>
                     {
                         if (e.NewItems.Count > 0)
-                            this.ContentManager.Reset();
+                        {
+                            this.Monitor.Log("Detected new asset loader, resetting cache...", LogLevel.Trace);
+                            this.ContentManager.InvalidateCache(p => true);
+                        }
                     };
                 }
             }
-            this.ContentManager.Reset();
+            this.Monitor.Log("Resetting cache to enable interception...", LogLevel.Trace);
+            this.ContentManager.InvalidateCache(p => true);
         }
 
         /// <summary>Reload translations for all mods.</summary>