Merge branch 'develop' into stable

15 files changed, 523 insertions, 243 deletions

diff --git a/src/SMAPI/Framework/Content/ContentCache.cs b/src/SMAPI/Framework/Content/ContentCache.cs
index 10c41d08..4508e641 100644
--- a/src/SMAPI/Framework/Content/ContentCache.cs
+++ b/src/SMAPI/Framework/Content/ContentCache.cs
@@ -57,14 +57,14 @@ namespace StardewModdingAPI.Framework.Content
         public ContentCache(LocalizedContentManager contentManager, Reflector reflection, char[] possiblePathSeparators, string preferredPathSeparator)
         {
             // init
-            this.Cache = reflection.GetPrivateField<Dictionary<string, object>>(contentManager, "loadedAssets").GetValue();
+            this.Cache = reflection.GetField<Dictionary<string, object>>(contentManager, "loadedAssets").GetValue();
             this.PossiblePathSeparators = possiblePathSeparators;
             this.PreferredPathSeparator = preferredPathSeparator;
 
             // get key normalisation logic
             if (Constants.TargetPlatform == Platform.Windows)
             {
-                IPrivateMethod method = reflection.GetPrivateMethod(typeof(TitleContainer), "GetCleanPath");
+                IReflectedMethod method = reflection.GetMethod(typeof(TitleContainer), "GetCleanPath");
                 this.NormaliseAssetNameForPlatform = path => method.Invoke<string>(path);
             }
             else
diff --git a/src/SMAPI/Framework/DeprecationManager.cs b/src/SMAPI/Framework/DeprecationManager.cs
index b07c6c7d..7a824a05 100644
--- a/src/SMAPI/Framework/DeprecationManager.cs
+++ b/src/SMAPI/Framework/DeprecationManager.cs
@@ -37,7 +37,7 @@ namespace StardewModdingAPI.Framework
         /// <param name="severity">How deprecated the code is.</param>
         public void Warn(string nounPhrase, string version, DeprecationLevel severity)
         {
-            this.Warn(this.ModRegistry.GetModFromStack(), nounPhrase, version, severity);
+            this.Warn(this.ModRegistry.GetFromStack()?.DisplayName, nounPhrase, version, severity);
         }
 
         /// <summary>Log a deprecation warning.</summary>
@@ -52,7 +52,7 @@ namespace StardewModdingAPI.Framework
                 return;
 
             // build message
-            string message = $"{source ?? "An unknown mod"} uses deprecated code ({nounPhrase}).";
+            string message = $"{source ?? "An unknown mod"} uses deprecated code ({nounPhrase} is deprecated since SMAPI {version}).";
             if (source == null)
                 message += $"{Environment.NewLine}{Environment.StackTrace}";
 
@@ -82,7 +82,7 @@ namespace StardewModdingAPI.Framework
         /// <returns>Returns whether the deprecation was successfully marked as warned. Returns <c>false</c> if it was already marked.</returns>
         public bool MarkWarned(string nounPhrase, string version)
         {
-            return this.MarkWarned(this.ModRegistry.GetModFromStack(), nounPhrase, version);
+            return this.MarkWarned(this.ModRegistry.GetFromStack()?.DisplayName, nounPhrase, version);
         }
 
         /// <summary>Mark a deprecation warning as already logged.</summary>
diff --git a/src/SMAPI/Framework/IModMetadata.cs b/src/SMAPI/Framework/IModMetadata.cs
index c21734a7..a36994fd 100644
--- a/src/SMAPI/Framework/IModMetadata.cs
+++ b/src/SMAPI/Framework/IModMetadata.cs
@@ -30,6 +30,9 @@ namespace StardewModdingAPI.Framework
         /// <summary>The mod instance (if it was loaded).</summary>
         IMod Mod { get; }
 
+        /// <summary>The mod-provided API (if any).</summary>
+        object Api { get; }
+
 
         /*********
         ** Public methods
@@ -43,5 +46,9 @@ namespace StardewModdingAPI.Framework
         /// <summary>Set the mod instance.</summary>
         /// <param name="mod">The mod instance to set.</param>
         IModMetadata SetMod(IMod mod);
+
+        /// <summary>Set the mod-provided API instance.</summary>
+        /// <param name="api">The mod-provided API.</param>
+        IModMetadata SetApi(object api);
     }
 }
diff --git a/src/SMAPI/Framework/InternalExtensions.cs b/src/SMAPI/Framework/InternalExtensions.cs
index 3709e05d..bec6c183 100644
--- a/src/SMAPI/Framework/InternalExtensions.cs
+++ b/src/SMAPI/Framework/InternalExtensions.cs
@@ -108,6 +108,15 @@ namespace StardewModdingAPI.Framework
             }
         }
 
+        /// <summary>Get the lowest exception in an exception stack.</summary>
+        /// <param name="exception">The exception from which to search.</param>
+        public static Exception GetInnermostException(this Exception exception)
+        {
+            while (exception.InnerException != null)
+                exception = exception.InnerException;
+            return exception;
+        }
+
         /****
         ** Sprite batch
         ****/
@@ -125,7 +134,7 @@ namespace StardewModdingAPI.Framework
 #endif
 
             // get result
-            return reflection.GetPrivateField<bool>(Game1.spriteBatch, fieldName).GetValue();
+            return reflection.GetField<bool>(Game1.spriteBatch, fieldName).GetValue();
         }
     }
 }
diff --git a/src/SMAPI/Framework/ModHelpers/ModRegistryHelper.cs b/src/SMAPI/Framework/ModHelpers/ModRegistryHelper.cs
index 9e824694..ea0dbb38 100644
--- a/src/SMAPI/Framework/ModHelpers/ModRegistryHelper.cs
+++ b/src/SMAPI/Framework/ModHelpers/ModRegistryHelper.cs
@@ -1,4 +1,6 @@
-using System.Collections.Generic;
+using System.Collections.Generic;
+using System.Linq;
+using StardewModdingAPI.Framework.Reflection;
 
 namespace StardewModdingAPI.Framework.ModHelpers
 {
@@ -11,6 +13,15 @@ namespace StardewModdingAPI.Framework.ModHelpers
         /// <summary>The underlying mod registry.</summary>
         private readonly ModRegistry Registry;
 
+        /// <summary>Encapsulates monitoring and logging for the mod.</summary>
+        private readonly IMonitor Monitor;
+
+        /// <summary>The mod IDs for APIs accessed by this instanced.</summary>
+        private readonly HashSet<string> AccessedModApis = new HashSet<string>();
+
+        /// <summary>Generates proxy classes to access mod APIs through an arbitrary interface.</summary>
+        private readonly InterfaceProxyBuilder ProxyBuilder;
+
 
         /*********
         ** Public methods
@@ -18,16 +29,20 @@ namespace StardewModdingAPI.Framework.ModHelpers
         /// <summary>Construct an instance.</summary>
         /// <param name="modID">The unique ID of the relevant mod.</param>
         /// <param name="registry">The underlying mod registry.</param>
-        public ModRegistryHelper(string modID, ModRegistry registry)
+        /// <param name="proxyBuilder">Generates proxy classes to access mod APIs through an arbitrary interface.</param>
+        /// <param name="monitor">Encapsulates monitoring and logging for the mod.</param>
+        public ModRegistryHelper(string modID, ModRegistry registry, InterfaceProxyBuilder proxyBuilder, IMonitor monitor)
             : base(modID)
         {
             this.Registry = registry;
+            this.ProxyBuilder = proxyBuilder;
+            this.Monitor = monitor;
         }
 
         /// <summary>Get metadata for all loaded mods.</summary>
         public IEnumerable<IManifest> GetAll()
         {
-            return this.Registry.GetAll();
+            return this.Registry.GetAll().Select(p => p.Manifest);
         }
 
         /// <summary>Get metadata for a loaded mod.</summary>
@@ -35,14 +50,56 @@ namespace StardewModdingAPI.Framework.ModHelpers
         /// <returns>Returns the matching mod's metadata, or <c>null</c> if not found.</returns>
         public IManifest Get(string uniqueID)
         {
-            return this.Registry.Get(uniqueID);
+            return this.Registry.Get(uniqueID)?.Manifest;
         }
 
         /// <summary>Get whether a mod has been loaded.</summary>
         /// <param name="uniqueID">The mod's unique ID.</param>
         public bool IsLoaded(string uniqueID)
         {
-            return this.Registry.IsLoaded(uniqueID);
+            return this.Registry.Get(uniqueID) != null;
+        }
+
+        /// <summary>Get the API provided by a mod, or <c>null</c> if it has none. This signature requires using the <see cref="IModHelper.Reflection"/> API to access the API's properties and methods.</summary>
+        public object GetApi(string uniqueID)
+        {
+            IModMetadata mod = this.Registry.Get(uniqueID);
+            if (mod?.Api != null && this.AccessedModApis.Add(mod.Manifest.UniqueID))
+                this.Monitor.Log($"Accessed mod-provided API for {mod.DisplayName}.", LogLevel.Trace);
+            return mod?.Api;
+        }
+
+        /// <summary>Get the API provided by a mod, mapped to a given interface which specifies the expected properties and methods. If the mod has no API or it's not compatible with the given interface, get <c>null</c>.</summary>
+        /// <typeparam name="TInterface">The interface which matches the properties and methods you intend to access.</typeparam>
+        /// <param name="uniqueID">The mod's unique ID.</param>
+        public TInterface GetApi<TInterface>(string uniqueID) where TInterface : class
+        {
+            // validate
+            if (!this.Registry.AreAllModsInitialised)
+            {
+                this.Monitor.Log("Tried to access a mod-provided API before all mods were initialised.", LogLevel.Error);
+                return null;
+            }
+            if (!typeof(TInterface).IsInterface)
+            {
+                this.Monitor.Log("Tried to map a mod-provided API to a class; must be a public interface.", LogLevel.Error);
+                return null;
+            }
+            if (!typeof(TInterface).IsPublic)
+            {
+                this.Monitor.Log("Tried to map a mod-provided API to a non-public interface; must be a public interface.", LogLevel.Error);
+                return null;
+            }
+
+            // get raw API
+            object api = this.GetApi(uniqueID);
+            if (api == null)
+                return null;
+
+            // get API of type
+            if (api is TInterface castApi)
+                return castApi;
+            return this.ProxyBuilder.CreateProxy<TInterface>(api, this.ModID, uniqueID);
         }
     }
 }
diff --git a/src/SMAPI/Framework/ModHelpers/ReflectionHelper.cs b/src/SMAPI/Framework/ModHelpers/ReflectionHelper.cs
index 8788b142..81453003 100644
--- a/src/SMAPI/Framework/ModHelpers/ReflectionHelper.cs
+++ b/src/SMAPI/Framework/ModHelpers/ReflectionHelper.cs
@@ -17,6 +17,9 @@ namespace StardewModdingAPI.Framework.ModHelpers
         /// <summary>The mod name for error messages.</summary>
         private readonly string ModName;
 
+        /// <summary>Manages deprecation warnings.</summary>
+        private readonly DeprecationManager DeprecationManager;
+
 
         /*********
         ** Public methods
@@ -25,15 +28,88 @@ namespace StardewModdingAPI.Framework.ModHelpers
         /// <param name="modID">The unique ID of the relevant mod.</param>
         /// <param name="modName">The mod name for error messages.</param>
         /// <param name="reflector">The underlying reflection helper.</param>
-        public ReflectionHelper(string modID, string modName, Reflector reflector)
+        /// <param name="deprecationManager">Manages deprecation warnings.</param>
+        public ReflectionHelper(string modID, string modName, Reflector reflector, DeprecationManager deprecationManager)
             : base(modID)
         {
             this.ModName = modName;
             this.Reflector = reflector;
+            this.DeprecationManager = deprecationManager;
+        }
+
+        /// <summary>Get an instance field.</summary>
+        /// <typeparam name="TValue">The field type.</typeparam>
+        /// <param name="obj">The object which has the field.</param>
+        /// <param name="name">The field name.</param>
+        /// <param name="required">Whether to throw an exception if the field is not found.</param>
+        public IReflectedField<TValue> GetField<TValue>(object obj, string name, bool required = true)
+        {
+            return this.AssertAccessAllowed(
+                this.Reflector.GetField<TValue>(obj, name, required)
+            );
+        }
+
+        /// <summary>Get a static field.</summary>
+        /// <typeparam name="TValue">The field type.</typeparam>
+        /// <param name="type">The type which has the field.</param>
+        /// <param name="name">The field name.</param>
+        /// <param name="required">Whether to throw an exception if the field is not found.</param>
+        public IReflectedField<TValue> GetField<TValue>(Type type, string name, bool required = true)
+        {
+            return this.AssertAccessAllowed(
+                this.Reflector.GetField<TValue>(type, name, required)
+            );
+        }
+
+        /// <summary>Get an instance property.</summary>
+        /// <typeparam name="TValue">The property type.</typeparam>
+        /// <param name="obj">The object which has the property.</param>
+        /// <param name="name">The property name.</param>
+        /// <param name="required">Whether to throw an exception if the property is not found.</param>
+        public IReflectedProperty<TValue> GetProperty<TValue>(object obj, string name, bool required = true)
+        {
+            return this.AssertAccessAllowed(
+                this.Reflector.GetProperty<TValue>(obj, name, required)
+            );
+        }
+
+        /// <summary>Get a static property.</summary>
+        /// <typeparam name="TValue">The property type.</typeparam>
+        /// <param name="type">The type which has the property.</param>
+        /// <param name="name">The property name.</param>
+        /// <param name="required">Whether to throw an exception if the property is not found.</param>
+        public IReflectedProperty<TValue> GetProperty<TValue>(Type type, string name, bool required = true)
+        {
+            return this.AssertAccessAllowed(
+                this.Reflector.GetProperty<TValue>(type, name, required)
+            );
+        }
+
+        /// <summary>Get an instance method.</summary>
+        /// <param name="obj">The object which has the method.</param>
+        /// <param name="name">The field name.</param>
+        /// <param name="required">Whether to throw an exception if the field is not found.</param>
+        public IReflectedMethod GetMethod(object obj, string name, bool required = true)
+        {
+            return this.AssertAccessAllowed(
+                this.Reflector.GetMethod(obj, name, required)
+            );
+        }
+
+        /// <summary>Get a static method.</summary>
+        /// <param name="type">The type which has the method.</param>
+        /// <param name="name">The field name.</param>
+        /// <param name="required">Whether to throw an exception if the field is not found.</param>
+        public IReflectedMethod GetMethod(Type type, string name, bool required = true)
+        {
+            return this.AssertAccessAllowed(
+                this.Reflector.GetMethod(type, name, required)
+            );
         }
 
+
         /****
-        ** Fields
+        ** Obsolete
         ****/
         /// <summary>Get a private instance field.</summary>
         /// <typeparam name="TValue">The field type.</typeparam>
@@ -41,11 +117,11 @@ namespace StardewModdingAPI.Framework.ModHelpers
         /// <param name="name">The field name.</param>
         /// <param name="required">Whether to throw an exception if the private field is not found.</param>
         /// <returns>Returns the field wrapper, or <c>null</c> if the field doesn't exist and <paramref name="required"/> is <c>false</c>.</returns>
+        [Obsolete]
         public IPrivateField<TValue> GetPrivateField<TValue>(object obj, string name, bool required = true)
         {
-            return this.AssertAccessAllowed(
-                this.Reflector.GetPrivateField<TValue>(obj, name, required)
-            );
+            this.DeprecationManager.Warn($"{nameof(IReflectionHelper)}.GetPrivate*", "2.3", DeprecationLevel.Notice);
+            return (IPrivateField<TValue>)this.GetField<TValue>(obj, name, required);
         }
 
         /// <summary>Get a private static field.</summary>
@@ -53,26 +129,23 @@ namespace StardewModdingAPI.Framework.ModHelpers
         /// <param name="type">The type which has the field.</param>
         /// <param name="name">The field name.</param>
         /// <param name="required">Whether to throw an exception if the private field is not found.</param>
+        [Obsolete]
         public IPrivateField<TValue> GetPrivateField<TValue>(Type type, string name, bool required = true)
         {
-            return this.AssertAccessAllowed(
-                this.Reflector.GetPrivateField<TValue>(type, name, required)
-            );
+            this.DeprecationManager.Warn($"{nameof(IReflectionHelper)}.GetPrivate*", "2.3", DeprecationLevel.Notice);
+            return (IPrivateField<TValue>)this.GetField<TValue>(type, name, required);
         }
 
-        /****
-        ** Properties
-        ****/
         /// <summary>Get a private instance property.</summary>
         /// <typeparam name="TValue">The property type.</typeparam>
         /// <param name="obj">The object which has the property.</param>
         /// <param name="name">The property name.</param>
         /// <param name="required">Whether to throw an exception if the private property is not found.</param>
+        [Obsolete]
         public IPrivateProperty<TValue> GetPrivateProperty<TValue>(object obj, string name, bool required = true)
         {
-            return this.AssertAccessAllowed(
-                this.Reflector.GetPrivateProperty<TValue>(obj, name, required)
-               );
+            this.DeprecationManager.Warn($"{nameof(IReflectionHelper)}.GetPrivate*", "2.3", DeprecationLevel.Notice);
+            return (IPrivateProperty<TValue>)this.GetProperty<TValue>(obj, name, required);
         }
 
         /// <summary>Get a private static property.</summary>
@@ -80,17 +153,13 @@ namespace StardewModdingAPI.Framework.ModHelpers
         /// <param name="type">The type which has the property.</param>
         /// <param name="name">The property name.</param>
         /// <param name="required">Whether to throw an exception if the private property is not found.</param>
+        [Obsolete]
         public IPrivateProperty<TValue> GetPrivateProperty<TValue>(Type type, string name, bool required = true)
         {
-            return this.AssertAccessAllowed(
-                this.Reflector.GetPrivateProperty<TValue>(type, name, required)
-            );
+            this.DeprecationManager.Warn($"{nameof(IReflectionHelper)}.GetPrivate*", "2.3", DeprecationLevel.Notice);
+            return (IPrivateProperty<TValue>)this.GetProperty<TValue>(type, name, required);
         }
 
-        /****
-        ** Field values
-        ** (shorthand since this is the most common case)
-        ****/
         /// <summary>Get the value of a private instance field.</summary>
         /// <typeparam name="TValue">The field type.</typeparam>
         /// <param name="obj">The object which has the field.</param>
@@ -101,9 +170,11 @@ namespace StardewModdingAPI.Framework.ModHelpers
         /// This is a shortcut for <see cref="GetPrivateField{TValue}(object,string,bool)"/> followed by <see cref="IPrivateField{TValue}.GetValue"/>.
         /// When <paramref name="required" /> is false, this will return the default value if reflection fails. If you need to check whether the field exists, use <see cref="GetPrivateField{TValue}(object,string,bool)" /> instead.
         /// </remarks>
+        [Obsolete]
         public TValue GetPrivateValue<TValue>(object obj, string name, bool required = true)
         {
-            IPrivateField<TValue> field = this.GetPrivateField<TValue>(obj, name, required);
+            this.DeprecationManager.Warn($"{nameof(IReflectionHelper)}.GetPrivate*", "2.3", DeprecationLevel.Notice);
+            IPrivateField<TValue> field = (IPrivateField<TValue>)this.GetField<TValue>(obj, name, required);
             return field != null
                 ? field.GetValue()
                 : default(TValue);
@@ -119,64 +190,36 @@ namespace StardewModdingAPI.Framework.ModHelpers
         /// This is a shortcut for <see cref="GetPrivateField{TValue}(Type,string,bool)"/> followed by <see cref="IPrivateField{TValue}.GetValue"/>.
         /// When <paramref name="required" /> is false, this will return the default value if reflection fails. If you need to check whether the field exists, use <see cref="GetPrivateField{TValue}(Type,string,bool)" /> instead.
         /// </remarks>
+        [Obsolete]
         public TValue GetPrivateValue<TValue>(Type type, string name, bool required = true)
         {
-            IPrivateField<TValue> field = this.GetPrivateField<TValue>(type, name, required);
+            this.DeprecationManager.Warn($"{nameof(IReflectionHelper)}.GetPrivate*", "2.3", DeprecationLevel.Notice);
+            IPrivateField<TValue> field = (IPrivateField<TValue>)this.GetField<TValue>(type, name, required);
             return field != null
                 ? field.GetValue()
                 : default(TValue);
         }
 
-        /****
-        ** Methods
-        ****/
         /// <summary>Get a private instance method.</summary>
         /// <param name="obj">The object which has the method.</param>
         /// <param name="name">The field name.</param>
         /// <param name="required">Whether to throw an exception if the private field is not found.</param>
+        [Obsolete]
         public IPrivateMethod GetPrivateMethod(object obj, string name, bool required = true)
         {
-            return this.AssertAccessAllowed(
-                this.Reflector.GetPrivateMethod(obj, name, required)
-            );
+            this.DeprecationManager.Warn($"{nameof(IReflectionHelper)}.GetPrivate*", "2.3", DeprecationLevel.Notice);
+            return (IPrivateMethod)this.GetMethod(obj, name, required);
         }
 
         /// <summary>Get a private static method.</summary>
         /// <param name="type">The type which has the method.</param>
         /// <param name="name">The field name.</param>
         /// <param name="required">Whether to throw an exception if the private field is not found.</param>
+        [Obsolete]
         public IPrivateMethod GetPrivateMethod(Type type, string name, bool required = true)
         {
-            return this.AssertAccessAllowed(
-                this.Reflector.GetPrivateMethod(type, name, required)
-            );
-        }
-
-        /****
-        ** Methods by signature
-        ****/
-        /// <summary>Get a private instance method.</summary>
-        /// <param name="obj">The object which has the method.</param>
-        /// <param name="name">The field name.</param>
-        /// <param name="argumentTypes">The argument types of the method signature to find.</param>
-        /// <param name="required">Whether to throw an exception if the private field is not found.</param>
-        public IPrivateMethod GetPrivateMethod(object obj, string name, Type[] argumentTypes, bool required = true)
-        {
-            return this.AssertAccessAllowed(
-                this.Reflector.GetPrivateMethod(obj, name, argumentTypes, required)
-            );
-        }
-
-        /// <summary>Get a private static method.</summary>
-        /// <param name="type">The type which has the method.</param>
-        /// <param name="name">The field name.</param>
-        /// <param name="argumentTypes">The argument types of the method signature to find.</param>
-        /// <param name="required">Whether to throw an exception if the private field is not found.</param>
-        public IPrivateMethod GetPrivateMethod(Type type, string name, Type[] argumentTypes, bool required = true)
-        {
-            return this.AssertAccessAllowed(
-                this.Reflector.GetPrivateMethod(type, name, argumentTypes, required)
-            );
+            this.DeprecationManager.Warn($"{nameof(IReflectionHelper)}.GetPrivate*", "2.3", DeprecationLevel.Notice);
+            return (IPrivateMethod)this.GetMethod(type, name, required);
         }
 
 
@@ -187,7 +230,7 @@ namespace StardewModdingAPI.Framework.ModHelpers
         /// <typeparam name="T">The field value type.</typeparam>
         /// <param name="field">The field being accessed.</param>
         /// <returns>Returns the same field instance for convenience.</returns>
-        private IPrivateField<T> AssertAccessAllowed<T>(IPrivateField<T> field)
+        private IReflectedField<T> AssertAccessAllowed<T>(IReflectedField<T> field)
         {
             this.AssertAccessAllowed(field?.FieldInfo);
             return field;
@@ -197,7 +240,7 @@ namespace StardewModdingAPI.Framework.ModHelpers
         /// <typeparam name="T">The property value type.</typeparam>
         /// <param name="property">The property being accessed.</param>
         /// <returns>Returns the same property instance for convenience.</returns>
-        private IPrivateProperty<T> AssertAccessAllowed<T>(IPrivateProperty<T> property)
+        private IReflectedProperty<T> AssertAccessAllowed<T>(IReflectedProperty<T> property)
         {
             this.AssertAccessAllowed(property?.PropertyInfo);
             return property;
@@ -206,7 +249,7 @@ namespace StardewModdingAPI.Framework.ModHelpers
         /// <summary>Assert that mods can use the reflection helper to access the given member.</summary>
         /// <param name="method">The method being accessed.</param>
         /// <returns>Returns the same method instance for convenience.</returns>
-        private IPrivateMethod AssertAccessAllowed(IPrivateMethod method)
+        private IReflectedMethod AssertAccessAllowed(IReflectedMethod method)
         {
             this.AssertAccessAllowed(method?.MethodInfo);
             return method;
diff --git a/src/SMAPI/Framework/ModLoading/ModMetadata.cs b/src/SMAPI/Framework/ModLoading/ModMetadata.cs
index 5055da75..30fe211b 100644
--- a/src/SMAPI/Framework/ModLoading/ModMetadata.cs
+++ b/src/SMAPI/Framework/ModLoading/ModMetadata.cs
@@ -29,6 +29,9 @@ namespace StardewModdingAPI.Framework.ModLoading
         /// <summary>The mod instance (if it was loaded).</summary>
         public IMod Mod { get; private set; }
 
+        /// <summary>The mod-provided API (if any).</summary>
+        public object Api { get; private set; }
+
 
         /*********
         ** Public methods
@@ -64,5 +67,13 @@ namespace StardewModdingAPI.Framework.ModLoading
             this.Mod = mod;
             return this;
         }
+
+        /// <summary>Set the mod-provided API instance.</summary>
+        /// <param name="api">The mod-provided API.</param>
+        public IModMetadata SetApi(object api)
+        {
+            this.Api = api;
+            return this;
+        }
     }
 }
diff --git a/src/SMAPI/Framework/ModRegistry.cs b/src/SMAPI/Framework/ModRegistry.cs
index 9dde7a20..453d2868 100644
--- a/src/SMAPI/Framework/ModRegistry.cs
+++ b/src/SMAPI/Framework/ModRegistry.cs
@@ -15,26 +15,34 @@ namespace StardewModdingAPI.Framework
         /// <summary>The registered mod data.</summary>
         private readonly List<IModMetadata> Mods = new List<IModMetadata>();
 
-        /// <summary>The friendly mod names treated as deprecation warning sources (assembly full name => mod name).</summary>
-        private readonly IDictionary<string, string> ModNamesByAssembly = new Dictionary<string, string>();
+        /// <summary>An assembly full name => mod lookup.</summary>
+        private readonly IDictionary<string, IModMetadata> ModNamesByAssembly = new Dictionary<string, IModMetadata>();
+
+        /// <summary>Whether all mods have been initialised and their <see cref="IMod.Entry"/> method called.</summary>
+        public bool AreAllModsInitialised { get; set; }
 
 
         /*********
         ** Public methods
         *********/
-        /****
-        ** Basic metadata
-        ****/
+        /// <summary>Register a mod as a possible source of deprecation warnings.</summary>
+        /// <param name="metadata">The mod metadata.</param>
+        public void Add(IModMetadata metadata)
+        {
+            this.Mods.Add(metadata);
+            this.ModNamesByAssembly[metadata.Mod.GetType().Assembly.FullName] = metadata;
+        }
+
         /// <summary>Get metadata for all loaded mods.</summary>
-        public IEnumerable<IManifest> GetAll()
+        public IEnumerable<IModMetadata> GetAll()
         {
-            return this.Mods.Select(p => p.Manifest);
+            return this.Mods.Select(p => p);
         }
 
         /// <summary>Get metadata for a loaded mod.</summary>
         /// <param name="uniqueID">The mod's unique ID.</param>
         /// <returns>Returns the matching mod's metadata, or <c>null</c> if not found.</returns>
-        public IManifest Get(string uniqueID)
+        public IModMetadata Get(string uniqueID)
         {
             // normalise search ID
             if (string.IsNullOrWhiteSpace(uniqueID))
@@ -42,37 +50,13 @@ namespace StardewModdingAPI.Framework
             uniqueID = uniqueID.Trim();
 
             // find match
-            return this.GetAll().FirstOrDefault(p => p.UniqueID.Trim().Equals(uniqueID, StringComparison.InvariantCultureIgnoreCase));
-        }
-
-        /// <summary>Get whether a mod has been loaded.</summary>
-        /// <param name="uniqueID">The mod's unique ID.</param>
-        public bool IsLoaded(string uniqueID)
-        {
-            return this.Get(uniqueID) != null;
-        }
-
-        /****
-        ** Mod data
-        ****/
-        /// <summary>Register a mod as a possible source of deprecation warnings.</summary>
-        /// <param name="metadata">The mod metadata.</param>
-        public void Add(IModMetadata metadata)
-        {
-            this.Mods.Add(metadata);
-            this.ModNamesByAssembly[metadata.Mod.GetType().Assembly.FullName] = metadata.DisplayName;
-        }
-
-        /// <summary>Get all enabled mods.</summary>
-        public IEnumerable<IModMetadata> GetMods()
-        {
-            return (from mod in this.Mods select mod);
+            return this.GetAll().FirstOrDefault(p => p.Manifest.UniqueID.Trim().Equals(uniqueID, StringComparison.InvariantCultureIgnoreCase));
         }
 
-        /// <summary>Get the friendly mod name which defines a type.</summary>
+        /// <summary>Get the mod metadata from one of its assemblies.</summary>
         /// <param name="type">The type to check.</param>
         /// <returns>Returns the mod name, or <c>null</c> if the type isn't part of a known mod.</returns>
-        public string GetModFrom(Type type)
+        public IModMetadata GetFrom(Type type)
         {
             // null
             if (type == null)
@@ -89,7 +73,7 @@ namespace StardewModdingAPI.Framework
 
         /// <summary>Get the friendly name for the closest assembly registered as a source of deprecation warnings.</summary>
         /// <returns>Returns the source name, or <c>null</c> if no registered assemblies were found.</returns>
-        public string GetModFromStack()
+        public IModMetadata GetFromStack()
         {
             // get stack frames
             StackTrace stack = new StackTrace();
@@ -101,9 +85,9 @@ namespace StardewModdingAPI.Framework
             foreach (StackFrame frame in frames)
             {
                 MethodBase method = frame.GetMethod();
-                string name = this.GetModFrom(method.ReflectedType);
-                if (name != null)
-                    return name;
+                IModMetadata mod = this.GetFrom(method.ReflectedType);
+                if (mod != null)
+                    return mod;
             }
 
             // no known assembly found
diff --git a/src/SMAPI/Framework/Reflection/InterfaceProxyBuilder.cs b/src/SMAPI/Framework/Reflection/InterfaceProxyBuilder.cs
new file mode 100644
index 00000000..5abebc18
--- /dev/null
+++ b/src/SMAPI/Framework/Reflection/InterfaceProxyBuilder.cs
@@ -0,0 +1,138 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Reflection.Emit;
+
+namespace StardewModdingAPI.Framework.Reflection
+{
+    /// <summary>Generates proxy classes to access mod APIs through an arbitrary interface.</summary>
+    internal class InterfaceProxyBuilder
+    {
+        /*********
+        ** Properties
+        *********/
+        /// <summary>The CLR module in which to create proxy classes.</summary>
+        private readonly ModuleBuilder ModuleBuilder;
+
+        /// <summary>The generated proxy types.</summary>
+        private readonly IDictionary<string, Type> GeneratedTypes = new Dictionary<string, Type>();
+
+
+        /*********
+        ** Public methods
+        *********/
+        /// <summary>Construct an instance.</summary>
+        public InterfaceProxyBuilder()
+        {
+            AssemblyBuilder assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(new AssemblyName($"StardewModdingAPI.Proxies, Version={this.GetType().Assembly.GetName().Version}, Culture=neutral"), AssemblyBuilderAccess.Run);
+            this.ModuleBuilder = assemblyBuilder.DefineDynamicModule("StardewModdingAPI.Proxies");
+        }
+
+        /// <summary>Create an API proxy.</summary>
+        /// <typeparam name="TInterface">The interface through which to access the API.</typeparam>
+        /// <param name="instance">The API instance to access.</param>
+        /// <param name="sourceModID">The unique ID of the mod consuming the API.</param>
+        /// <param name="targetModID">The unique ID of the mod providing the API.</param>
+        public TInterface CreateProxy<TInterface>(object instance, string sourceModID, string targetModID)
+            where TInterface : class
+        {
+            // validate
+            if (instance == null)
+                throw new InvalidOperationException("Can't proxy access to a null API.");
+            if (!typeof(TInterface).IsInterface)
+                throw new InvalidOperationException("The proxy type must be an interface, not a class.");
+
+            // get proxy type
+            Type targetType = instance.GetType();
+            string proxyTypeName = $"StardewModdingAPI.Proxies.From<{sourceModID}_{typeof(TInterface).FullName}>_To<{targetModID}_{targetType.FullName}>";
+            if (!this.GeneratedTypes.TryGetValue(proxyTypeName, out Type type))
+            {
+                type = this.CreateProxyType(proxyTypeName, typeof(TInterface), targetType);
+                this.GeneratedTypes[proxyTypeName] = type;
+            }
+
+            // create instance
+            ConstructorInfo constructor = type.GetConstructor(new[] { targetType });
+            if (constructor == null)
+                throw new InvalidOperationException($"Couldn't find the constructor for generated proxy type '{proxyTypeName}'."); // should never happen
+            return (TInterface)constructor.Invoke(new[] { instance });
+        }
+
+
+        /*********
+        ** Private methods
+        *********/
+        /// <summary>Define a class which proxies access to a target type through an interface.</summary>
+        /// <param name="proxyTypeName">The name of the proxy type to generate.</param>
+        /// <param name="interfaceType">The interface type through which to access the target.</param>
+        /// <param name="targetType">The target type to access.</param>
+        private Type CreateProxyType(string proxyTypeName, Type interfaceType, Type targetType)
+        {
+            // define proxy type
+            TypeBuilder proxyBuilder = this.ModuleBuilder.DefineType(proxyTypeName, TypeAttributes.Public | TypeAttributes.Class);
+            proxyBuilder.AddInterfaceImplementation(interfaceType);
+
+            // create field to store target instance
+            FieldBuilder field = proxyBuilder.DefineField("__Target", targetType, FieldAttributes.Private);
+
+            // create constructor which accepts target instance
+            {
+                ConstructorBuilder constructor = proxyBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard | CallingConventions.HasThis, new[] { targetType });
+                ILGenerator il = constructor.GetILGenerator();
+
+                il.Emit(OpCodes.Ldarg_0); // this
+                // ReSharper disable once AssignNullToNotNullAttribute -- never null
+                il.Emit(OpCodes.Call, typeof(object).GetConstructor(new Type[0])); // call base constructor
+                il.Emit(OpCodes.Ldarg_0);      // this
+                il.Emit(OpCodes.Ldarg_1);      // load argument
+                il.Emit(OpCodes.Stfld, field); // set field to loaded argument
+                il.Emit(OpCodes.Ret);
+            }
+
+            // proxy methods
+            foreach (MethodInfo proxyMethod in interfaceType.GetMethods())
+            {
+                var targetMethod = targetType.GetMethod(proxyMethod.Name, proxyMethod.GetParameters().Select(a => a.ParameterType).ToArray());
+                if (targetMethod == null)
+                    throw new InvalidOperationException($"The {interfaceType.FullName} interface defines method {proxyMethod.Name} which doesn't exist in the API.");
+
+                this.ProxyMethod(proxyBuilder, targetMethod, field);
+            }
+
+            // create type
+            return proxyBuilder.CreateType();
+        }
+
+        /// <summary>Define a method which proxies access to a method on the target.</summary>
+        /// <param name="proxyBuilder">The proxy type being generated.</param>
+        /// <param name="target">The target method.</param>
+        /// <param name="instanceField">The proxy field containing the API instance.</param>
+        private void ProxyMethod(TypeBuilder proxyBuilder, MethodInfo target, FieldBuilder instanceField)
+        {
+            Type[] argTypes = target.GetParameters().Select(a => a.ParameterType).ToArray();
+
+            // create method
+            MethodBuilder methodBuilder = proxyBuilder.DefineMethod(target.Name, MethodAttributes.Public | MethodAttributes.Final | MethodAttributes.Virtual);
+            methodBuilder.SetParameters(argTypes);
+            methodBuilder.SetReturnType(target.ReturnType);
+
+            // create method body
+            {
+                ILGenerator il = methodBuilder.GetILGenerator();
+
+                // load target instance
+                il.Emit(OpCodes.Ldarg_0);
+                il.Emit(OpCodes.Ldfld, instanceField);
+
+                // invoke target method on instance
+                for (int i = 0; i < argTypes.Length; i++)
+                    il.Emit(OpCodes.Ldarg, i + 1);
+                il.Emit(OpCodes.Call, target);
+
+                // return result
+                il.Emit(OpCodes.Ret);
+            }
+        }
+    }
+}
diff --git a/src/SMAPI/Framework/Reflection/PrivateField.cs b/src/SMAPI/Framework/Reflection/ReflectedField.cs
index 0bf45969..ad1557bb 100644
--- a/src/SMAPI/Framework/Reflection/PrivateField.cs
+++ b/src/SMAPI/Framework/Reflection/ReflectedField.cs
@@ -1,11 +1,11 @@
-using System;
+using System;
 using System.Reflection;
 
 namespace StardewModdingAPI.Framework.Reflection
 {
-    /// <summary>A private field obtained through reflection.</summary>
+    /// <summary>A field obtained through reflection.</summary>
     /// <typeparam name="TValue">The field value type.</typeparam>
-    internal class PrivateField<TValue> : IPrivateField<TValue>
+    internal class ReflectedField<TValue> : IPrivateField<TValue>, IReflectedField<TValue>
     {
         /*********
         ** Properties
@@ -37,7 +37,7 @@ namespace StardewModdingAPI.Framework.Reflection
         /// <param name="isStatic">Whether the field is static.</param>
         /// <exception cref="ArgumentNullException">The <paramref name="parentType"/> or <paramref name="field"/> is null.</exception>
         /// <exception cref="ArgumentException">The <paramref name="obj"/> is null for a non-static field, or not null for a static field.</exception>
-        public PrivateField(Type parentType, object obj, FieldInfo field, bool isStatic)
+        public ReflectedField(Type parentType, object obj, FieldInfo field, bool isStatic)
         {
             // validate
             if (parentType == null)
@@ -64,11 +64,11 @@ namespace StardewModdingAPI.Framework.Reflection
             }
             catch (InvalidCastException)
             {
-                throw new InvalidCastException($"Can't convert the private {this.DisplayName} field from {this.FieldInfo.FieldType.FullName} to {typeof(TValue).FullName}.");
+                throw new InvalidCastException($"Can't convert the {this.DisplayName} field from {this.FieldInfo.FieldType.FullName} to {typeof(TValue).FullName}.");
             }
             catch (Exception ex)
             {
-                throw new Exception($"Couldn't get the value of the private {this.DisplayName} field", ex);
+                throw new Exception($"Couldn't get the value of the {this.DisplayName} field", ex);
             }
         }
 
@@ -82,11 +82,11 @@ namespace StardewModdingAPI.Framework.Reflection
             }
             catch (InvalidCastException)
             {
-                throw new InvalidCastException($"Can't assign the private {this.DisplayName} field a {typeof(TValue).FullName} value, must be compatible with {this.FieldInfo.FieldType.FullName}.");
+                throw new InvalidCastException($"Can't assign the {this.DisplayName} field a {typeof(TValue).FullName} value, must be compatible with {this.FieldInfo.FieldType.FullName}.");
             }
             catch (Exception ex)
             {
-                throw new Exception($"Couldn't set the value of the private {this.DisplayName} field", ex);
+                throw new Exception($"Couldn't set the value of the {this.DisplayName} field", ex);
             }
         }
     }
diff --git a/src/SMAPI/Framework/Reflection/PrivateMethod.cs b/src/SMAPI/Framework/Reflection/ReflectedMethod.cs
index ba2374f4..376de869 100644
--- a/src/SMAPI/Framework/Reflection/PrivateMethod.cs
+++ b/src/SMAPI/Framework/Reflection/ReflectedMethod.cs
@@ -3,8 +3,8 @@ using System.Reflection;
 
 namespace StardewModdingAPI.Framework.Reflection
 {
-    /// <summary>A private method obtained through reflection.</summary>
-    internal class PrivateMethod : IPrivateMethod
+    /// <summary>A method obtained through reflection.</summary>
+    internal class ReflectedMethod : IPrivateMethod, IReflectedMethod
     {
         /*********
         ** Properties
@@ -33,10 +33,10 @@ namespace StardewModdingAPI.Framework.Reflection
         /// <param name="parentType">The type that has the method.</param>
         /// <param name="obj">The object that has the instance method(if applicable).</param>
         /// <param name="method">The reflection metadata.</param>
-        /// <param name="isStatic">Whether the field is static.</param>
+        /// <param name="isStatic">Whether the method is static.</param>
         /// <exception cref="ArgumentNullException">The <paramref name="parentType"/> or <paramref name="method"/> is null.</exception>
         /// <exception cref="ArgumentException">The <paramref name="obj"/> is null for a non-static method, or not null for a static method.</exception>
-        public PrivateMethod(Type parentType, object obj, MethodInfo method, bool isStatic)
+        public ReflectedMethod(Type parentType, object obj, MethodInfo method, bool isStatic)
         {
             // validate
             if (parentType == null)
@@ -67,7 +67,7 @@ namespace StardewModdingAPI.Framework.Reflection
             }
             catch (Exception ex)
             {
-                throw new Exception($"Couldn't invoke the private {this.DisplayName} field", ex);
+                throw new Exception($"Couldn't invoke the {this.DisplayName} method", ex);
             }
 
             // cast return value
@@ -77,7 +77,7 @@ namespace StardewModdingAPI.Framework.Reflection
             }
             catch (InvalidCastException)
             {
-                throw new InvalidCastException($"Can't convert the return value of the private {this.DisplayName} method from {this.MethodInfo.ReturnType.FullName} to {typeof(TValue).FullName}.");
+                throw new InvalidCastException($"Can't convert the return value of the {this.DisplayName} method from {this.MethodInfo.ReturnType.FullName} to {typeof(TValue).FullName}.");
             }
         }
 
@@ -92,8 +92,8 @@ namespace StardewModdingAPI.Framework.Reflection
             }
             catch (Exception ex)
             {
-                throw new Exception($"Couldn't invoke the private {this.DisplayName} field", ex);
+                throw new Exception($"Couldn't invoke the {this.DisplayName} method", ex);
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/SMAPI/Framework/Reflection/PrivateProperty.cs b/src/SMAPI/Framework/Reflection/ReflectedProperty.cs
index be346d71..d6c964c1 100644
--- a/src/SMAPI/Framework/Reflection/PrivateProperty.cs
+++ b/src/SMAPI/Framework/Reflection/ReflectedProperty.cs
@@ -3,9 +3,9 @@ using System.Reflection;
 
 namespace StardewModdingAPI.Framework.Reflection
 {
-    /// <summary>A private property obtained through reflection.</summary>
+    /// <summary>A property obtained through reflection.</summary>
     /// <typeparam name="TValue">The property value type.</typeparam>
-    internal class PrivateProperty<TValue> : IPrivateProperty<TValue>
+    internal class ReflectedProperty<TValue> : IPrivateProperty<TValue>, IReflectedProperty<TValue>
     {
         /*********
         ** Properties
@@ -14,10 +14,10 @@ namespace StardewModdingAPI.Framework.Reflection
         private readonly string DisplayName;
 
         /// <summary>The underlying property getter.</summary>
-        private readonly Func<TValue> GetterDelegate;
+        private readonly Func<TValue> GetMethod;
 
         /// <summary>The underlying property setter.</summary>
-        private readonly Action<TValue> SetterDelegate;
+        private readonly Action<TValue> SetMethod;
 
 
         /*********
@@ -31,13 +31,13 @@ namespace StardewModdingAPI.Framework.Reflection
         ** Public methods
         *********/
         /// <summary>Construct an instance.</summary>
-        /// <param name="parentType">The type that has the field.</param>
-        /// <param name="obj">The object that has the instance field (if applicable).</param>
+        /// <param name="parentType">The type that has the property.</param>
+        /// <param name="obj">The object that has the instance property (if applicable).</param>
         /// <param name="property">The reflection metadata.</param>
-        /// <param name="isStatic">Whether the field is static.</param>
+        /// <param name="isStatic">Whether the property is static.</param>
         /// <exception cref="ArgumentNullException">The <paramref name="parentType"/> or <paramref name="property"/> is null.</exception>
-        /// <exception cref="ArgumentException">The <paramref name="obj"/> is null for a non-static field, or not null for a static field.</exception>
-        public PrivateProperty(Type parentType, object obj, PropertyInfo property, bool isStatic)
+        /// <exception cref="ArgumentException">The <paramref name="obj"/> is null for a non-static property, or not null for a static property.</exception>
+        public ReflectedProperty(Type parentType, object obj, PropertyInfo property, bool isStatic)
         {
             // validate input
             if (parentType == null)
@@ -55,24 +55,29 @@ namespace StardewModdingAPI.Framework.Reflection
             this.DisplayName = $"{parentType.FullName}::{property.Name}";
             this.PropertyInfo = property;
 
-            this.GetterDelegate = (Func<TValue>)Delegate.CreateDelegate(typeof(Func<TValue>), obj, this.PropertyInfo.GetMethod);
-            this.SetterDelegate = (Action<TValue>)Delegate.CreateDelegate(typeof(Action<TValue>), obj, this.PropertyInfo.SetMethod);
+            if (this.PropertyInfo.GetMethod != null)
+                this.GetMethod = (Func<TValue>)Delegate.CreateDelegate(typeof(Func<TValue>), obj, this.PropertyInfo.GetMethod);
+            if (this.PropertyInfo.SetMethod != null)
+                this.SetMethod = (Action<TValue>)Delegate.CreateDelegate(typeof(Action<TValue>), obj, this.PropertyInfo.SetMethod);
         }
 
         /// <summary>Get the property value.</summary>
         public TValue GetValue()
         {
+            if (this.GetMethod == null)
+                throw new InvalidOperationException($"The {this.DisplayName} property has no get method.");
+
             try
             {
-                return this.GetterDelegate();
+                return this.GetMethod();
             }
             catch (InvalidCastException)
             {
-                throw new InvalidCastException($"Can't convert the private {this.DisplayName} property from {this.PropertyInfo.PropertyType.FullName} to {typeof(TValue).FullName}.");
+                throw new InvalidCastException($"Can't convert the {this.DisplayName} property from {this.PropertyInfo.PropertyType.FullName} to {typeof(TValue).FullName}.");
             }
             catch (Exception ex)
             {
-                throw new Exception($"Couldn't get the value of the private {this.DisplayName} property", ex);
+                throw new Exception($"Couldn't get the value of the {this.DisplayName} property", ex);
             }
         }
 
@@ -80,17 +85,20 @@ namespace StardewModdingAPI.Framework.Reflection
         //// <param name="value">The value to set.</param>
         public void SetValue(TValue value)
         {
+            if (this.SetMethod == null)
+                throw new InvalidOperationException($"The {this.DisplayName} property has no set method.");
+
             try
             {
-                this.SetterDelegate(value);
+                this.SetMethod(value);
             }
             catch (InvalidCastException)
             {
-                throw new InvalidCastException($"Can't assign the private {this.DisplayName} property a {typeof(TValue).FullName} value, must be compatible with {this.PropertyInfo.PropertyType.FullName}.");
+                throw new InvalidCastException($"Can't assign the {this.DisplayName} property a {typeof(TValue).FullName} value, must be compatible with {this.PropertyInfo.PropertyType.FullName}.");
             }
             catch (Exception ex)
             {
-                throw new Exception($"Couldn't set the value of the private {this.DisplayName} property", ex);
+                throw new Exception($"Couldn't set the value of the {this.DisplayName} property", ex);
             }
         }
     }
diff --git a/src/SMAPI/Framework/Reflection/Reflector.cs b/src/SMAPI/Framework/Reflection/Reflector.cs
index 23a48505..910e3a54 100644
--- a/src/SMAPI/Framework/Reflection/Reflector.cs
+++ b/src/SMAPI/Framework/Reflection/Reflector.cs
@@ -5,7 +5,7 @@ using System.Runtime.Caching;
 
 namespace StardewModdingAPI.Framework.Reflection
 {
-    /// <summary>Provides helper methods for accessing private game code.</summary>
+    /// <summary>Provides helper methods for accessing inaccessible code.</summary>
     /// <remarks>This implementation searches up the type hierarchy, and caches the reflected fields and methods with a sliding expiry (to optimise performance without unnecessary memory usage).</remarks>
     internal class Reflector
     {
@@ -25,139 +25,139 @@ namespace StardewModdingAPI.Framework.Reflection
         /****
         ** Fields
         ****/
-        /// <summary>Get a private instance field.</summary>
+        /// <summary>Get a instance field.</summary>
         /// <typeparam name="TValue">The field type.</typeparam>
         /// <param name="obj">The object which has the field.</param>
         /// <param name="name">The field name.</param>
-        /// <param name="required">Whether to throw an exception if the private field is not found.</param>
+        /// <param name="required">Whether to throw an exception if the field is not found.</param>
         /// <returns>Returns the field wrapper, or <c>null</c> if the field doesn't exist and <paramref name="required"/> is <c>false</c>.</returns>
-        public IPrivateField<TValue> GetPrivateField<TValue>(object obj, string name, bool required = true)
+        public IReflectedField<TValue> GetField<TValue>(object obj, string name, bool required = true)
         {
             // validate
             if (obj == null)
-                throw new ArgumentNullException(nameof(obj), "Can't get a private instance field from a null object.");
+                throw new ArgumentNullException(nameof(obj), "Can't get a instance field from a null object.");
 
             // get field from hierarchy
-            IPrivateField<TValue> field = this.GetFieldFromHierarchy<TValue>(obj.GetType(), obj, name, BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
+            IReflectedField<TValue> field = this.GetFieldFromHierarchy<TValue>(obj.GetType(), obj, name, BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
             if (required && field == null)
-                throw new InvalidOperationException($"The {obj.GetType().FullName} object doesn't have a private '{name}' instance field.");
+                throw new InvalidOperationException($"The {obj.GetType().FullName} object doesn't have a '{name}' instance field.");
             return field;
         }
 
-        /// <summary>Get a private static field.</summary>
+        /// <summary>Get a static field.</summary>
         /// <typeparam name="TValue">The field type.</typeparam>
         /// <param name="type">The type which has the field.</param>
         /// <param name="name">The field name.</param>
-        /// <param name="required">Whether to throw an exception if the private field is not found.</param>
-        public IPrivateField<TValue> GetPrivateField<TValue>(Type type, string name, bool required = true)
+        /// <param name="required">Whether to throw an exception if the field is not found.</param>
+        public IReflectedField<TValue> GetField<TValue>(Type type, string name, bool required = true)
         {
             // get field from hierarchy
-            IPrivateField<TValue> field = this.GetFieldFromHierarchy<TValue>(type, null, name, BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Public);
+            IReflectedField<TValue> field = this.GetFieldFromHierarchy<TValue>(type, null, name, BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Public);
             if (required && field == null)
-                throw new InvalidOperationException($"The {type.FullName} object doesn't have a private '{name}' static field.");
+                throw new InvalidOperationException($"The {type.FullName} object doesn't have a '{name}' static field.");
             return field;
         }
 
         /****
         ** Properties
         ****/
-        /// <summary>Get a private instance property.</summary>
+        /// <summary>Get a instance property.</summary>
         /// <typeparam name="TValue">The property type.</typeparam>
         /// <param name="obj">The object which has the property.</param>
         /// <param name="name">The property name.</param>
-        /// <param name="required">Whether to throw an exception if the private property is not found.</param>
-        public IPrivateProperty<TValue> GetPrivateProperty<TValue>(object obj, string name, bool required = true)
+        /// <param name="required">Whether to throw an exception if the property is not found.</param>
+        public IReflectedProperty<TValue> GetProperty<TValue>(object obj, string name, bool required = true)
         {
             // validate
             if (obj == null)
-                throw new ArgumentNullException(nameof(obj), "Can't get a private instance property from a null object.");
+                throw new ArgumentNullException(nameof(obj), "Can't get a instance property from a null object.");
 
             // get property from hierarchy
-            IPrivateProperty<TValue> property = this.GetPropertyFromHierarchy<TValue>(obj.GetType(), obj, name, BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
+            IReflectedProperty<TValue> property = this.GetPropertyFromHierarchy<TValue>(obj.GetType(), obj, name, BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
             if (required && property == null)
-                throw new InvalidOperationException($"The {obj.GetType().FullName} object doesn't have a private '{name}' instance property.");
+                throw new InvalidOperationException($"The {obj.GetType().FullName} object doesn't have a '{name}' instance property.");
             return property;
         }
 
-        /// <summary>Get a private static property.</summary>
+        /// <summary>Get a static property.</summary>
         /// <typeparam name="TValue">The property type.</typeparam>
         /// <param name="type">The type which has the property.</param>
         /// <param name="name">The property name.</param>
-        /// <param name="required">Whether to throw an exception if the private property is not found.</param>
-        public IPrivateProperty<TValue> GetPrivateProperty<TValue>(Type type, string name, bool required = true)
+        /// <param name="required">Whether to throw an exception if the property is not found.</param>
+        public IReflectedProperty<TValue> GetProperty<TValue>(Type type, string name, bool required = true)
         {
             // get field from hierarchy
-            IPrivateProperty<TValue> property = this.GetPropertyFromHierarchy<TValue>(type, null, name, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static);
+            IReflectedProperty<TValue> property = this.GetPropertyFromHierarchy<TValue>(type, null, name, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static);
             if (required && property == null)
-                throw new InvalidOperationException($"The {type.FullName} object doesn't have a private '{name}' static property.");
+                throw new InvalidOperationException($"The {type.FullName} object doesn't have a '{name}' static property.");
             return property;
         }
 
         /****
         ** Methods
         ****/
-        /// <summary>Get a private instance method.</summary>
+        /// <summary>Get a instance method.</summary>
         /// <param name="obj">The object which has the method.</param>
         /// <param name="name">The field name.</param>
-        /// <param name="required">Whether to throw an exception if the private field is not found.</param>
-        public IPrivateMethod GetPrivateMethod(object obj, string name, bool required = true)
+        /// <param name="required">Whether to throw an exception if the field is not found.</param>
+        public IReflectedMethod GetMethod(object obj, string name, bool required = true)
         {
             // validate
             if (obj == null)
-                throw new ArgumentNullException(nameof(obj), "Can't get a private instance method from a null object.");
+                throw new ArgumentNullException(nameof(obj), "Can't get a instance method from a null object.");
 
             // get method from hierarchy
-            IPrivateMethod method = this.GetMethodFromHierarchy(obj.GetType(), obj, name, BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
+            IReflectedMethod method = this.GetMethodFromHierarchy(obj.GetType(), obj, name, BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
             if (required && method == null)
-                throw new InvalidOperationException($"The {obj.GetType().FullName} object doesn't have a private '{name}' instance method.");
+                throw new InvalidOperationException($"The {obj.GetType().FullName} object doesn't have a '{name}' instance method.");
             return method;
         }
 
-        /// <summary>Get a private static method.</summary>
+        /// <summary>Get a static method.</summary>
         /// <param name="type">The type which has the method.</param>
         /// <param name="name">The field name.</param>
-        /// <param name="required">Whether to throw an exception if the private field is not found.</param>
-        public IPrivateMethod GetPrivateMethod(Type type, string name, bool required = true)
+        /// <param name="required">Whether to throw an exception if the field is not found.</param>
+        public IReflectedMethod GetMethod(Type type, string name, bool required = true)
         {
             // get method from hierarchy
-            IPrivateMethod method = this.GetMethodFromHierarchy(type, null, name, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static);
+            IReflectedMethod method = this.GetMethodFromHierarchy(type, null, name, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static);
             if (required && method == null)
-                throw new InvalidOperationException($"The {type.FullName} object doesn't have a private '{name}' static method.");
+                throw new InvalidOperationException($"The {type.FullName} object doesn't have a '{name}' static method.");
             return method;
         }
 
         /****
         ** Methods by signature
         ****/
-        /// <summary>Get a private instance method.</summary>
+        /// <summary>Get a instance method.</summary>
         /// <param name="obj">The object which has the method.</param>
         /// <param name="name">The field name.</param>
         /// <param name="argumentTypes">The argument types of the method signature to find.</param>
-        /// <param name="required">Whether to throw an exception if the private field is not found.</param>
-        public IPrivateMethod GetPrivateMethod(object obj, string name, Type[] argumentTypes, bool required = true)
+        /// <param name="required">Whether to throw an exception if the field is not found.</param>
+        public IReflectedMethod GetMethod(object obj, string name, Type[] argumentTypes, bool required = true)
         {
             // validate parent
             if (obj == null)
-                throw new ArgumentNullException(nameof(obj), "Can't get a private instance method from a null object.");
+                throw new ArgumentNullException(nameof(obj), "Can't get a instance method from a null object.");
 
             // get method from hierarchy
-            PrivateMethod method = this.GetMethodFromHierarchy(obj.GetType(), obj, name, BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public, argumentTypes);
+            ReflectedMethod method = this.GetMethodFromHierarchy(obj.GetType(), obj, name, BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public, argumentTypes);
             if (required && method == null)
-                throw new InvalidOperationException($"The {obj.GetType().FullName} object doesn't have a private '{name}' instance method with that signature.");
+                throw new InvalidOperationException($"The {obj.GetType().FullName} object doesn't have a '{name}' instance method with that signature.");
             return method;
         }
 
-        /// <summary>Get a private static method.</summary>
+        /// <summary>Get a static method.</summary>
         /// <param name="type">The type which has the method.</param>
         /// <param name="name">The field name.</param>
         /// <param name="argumentTypes">The argument types of the method signature to find.</param>
-        /// <param name="required">Whether to throw an exception if the private field is not found.</param>
-        public IPrivateMethod GetPrivateMethod(Type type, string name, Type[] argumentTypes, bool required = true)
+        /// <param name="required">Whether to throw an exception if the field is not found.</param>
+        public IReflectedMethod GetMethod(Type type, string name, Type[] argumentTypes, bool required = true)
         {
             // get field from hierarchy
-            PrivateMethod method = this.GetMethodFromHierarchy(type, null, name, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static, argumentTypes);
+            ReflectedMethod method = this.GetMethodFromHierarchy(type, null, name, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static, argumentTypes);
             if (required && method == null)
-                throw new InvalidOperationException($"The {type.FullName} object doesn't have a private '{name}' static method with that signature.");
+                throw new InvalidOperationException($"The {type.FullName} object doesn't have a '{name}' static method with that signature.");
             return method;
         }
 
@@ -171,7 +171,7 @@ namespace StardewModdingAPI.Framework.Reflection
         /// <param name="obj">The object which has the field.</param>
         /// <param name="name">The field name.</param>
         /// <param name="bindingFlags">The reflection binding which flags which indicates what type of field to find.</param>
-        private IPrivateField<TValue> GetFieldFromHierarchy<TValue>(Type type, object obj, string name, BindingFlags bindingFlags)
+        private IReflectedField<TValue> GetFieldFromHierarchy<TValue>(Type type, object obj, string name, BindingFlags bindingFlags)
         {
             bool isStatic = bindingFlags.HasFlag(BindingFlags.Static);
             FieldInfo field = this.GetCached<FieldInfo>($"field::{isStatic}::{type.FullName}::{name}", () =>
@@ -183,7 +183,7 @@ namespace StardewModdingAPI.Framework.Reflection
             });
 
             return field != null
-                ? new PrivateField<TValue>(type, obj, field, isStatic)
+                ? new ReflectedField<TValue>(type, obj, field, isStatic)
                 : null;
         }
 
@@ -193,7 +193,7 @@ namespace StardewModdingAPI.Framework.Reflection
         /// <param name="obj">The object which has the property.</param>
         /// <param name="name">The property name.</param>
         /// <param name="bindingFlags">The reflection binding which flags which indicates what type of property to find.</param>
-        private IPrivateProperty<TValue> GetPropertyFromHierarchy<TValue>(Type type, object obj, string name, BindingFlags bindingFlags)
+        private IReflectedProperty<TValue> GetPropertyFromHierarchy<TValue>(Type type, object obj, string name, BindingFlags bindingFlags)
         {
             bool isStatic = bindingFlags.HasFlag(BindingFlags.Static);
             PropertyInfo property = this.GetCached<PropertyInfo>($"property::{isStatic}::{type.FullName}::{name}", () =>
@@ -205,7 +205,7 @@ namespace StardewModdingAPI.Framework.Reflection
             });
 
             return property != null
-                ? new PrivateProperty<TValue>(type, obj, property, isStatic)
+                ? new ReflectedProperty<TValue>(type, obj, property, isStatic)
                 : null;
         }
 
@@ -214,7 +214,7 @@ namespace StardewModdingAPI.Framework.Reflection
         /// <param name="obj">The object which has the method.</param>
         /// <param name="name">The method name.</param>
         /// <param name="bindingFlags">The reflection binding which flags which indicates what type of method to find.</param>
-        private IPrivateMethod GetMethodFromHierarchy(Type type, object obj, string name, BindingFlags bindingFlags)
+        private IReflectedMethod GetMethodFromHierarchy(Type type, object obj, string name, BindingFlags bindingFlags)
         {
             bool isStatic = bindingFlags.HasFlag(BindingFlags.Static);
             MethodInfo method = this.GetCached($"method::{isStatic}::{type.FullName}::{name}", () =>
@@ -226,7 +226,7 @@ namespace StardewModdingAPI.Framework.Reflection
             });
 
             return method != null
-                ? new PrivateMethod(type, obj, method, isStatic: bindingFlags.HasFlag(BindingFlags.Static))
+                ? new ReflectedMethod(type, obj, method, isStatic: bindingFlags.HasFlag(BindingFlags.Static))
                 : null;
         }
 
@@ -236,7 +236,7 @@ namespace StardewModdingAPI.Framework.Reflection
         /// <param name="name">The method name.</param>
         /// <param name="bindingFlags">The reflection binding which flags which indicates what type of method to find.</param>
         /// <param name="argumentTypes">The argument types of the method signature to find.</param>
-        private PrivateMethod GetMethodFromHierarchy(Type type, object obj, string name, BindingFlags bindingFlags, Type[] argumentTypes)
+        private ReflectedMethod GetMethodFromHierarchy(Type type, object obj, string name, BindingFlags bindingFlags, Type[] argumentTypes)
         {
             bool isStatic = bindingFlags.HasFlag(BindingFlags.Static);
             MethodInfo method = this.GetCached($"method::{isStatic}::{type.FullName}::{name}({string.Join(",", argumentTypes.Select(p => p.FullName))})", () =>
@@ -247,7 +247,7 @@ namespace StardewModdingAPI.Framework.Reflection
                 return methodInfo;
             });
             return method != null
-                ? new PrivateMethod(type, obj, method, isStatic)
+                ? new ReflectedMethod(type, obj, method, isStatic)
                 : null;
         }
 
diff --git a/src/SMAPI/Framework/SContentManager.cs b/src/SMAPI/Framework/SContentManager.cs
index 524b2d17..ebea6c84 100644
--- a/src/SMAPI/Framework/SContentManager.cs
+++ b/src/SMAPI/Framework/SContentManager.cs
@@ -45,7 +45,7 @@ namespace StardewModdingAPI.Framework
         private readonly ContentCache Cache;
 
         /// <summary>The private <see cref="LocalizedContentManager"/> method which generates the locale portion of an asset name.</summary>
-        private readonly IPrivateMethod GetKeyLocale;
+        private readonly IReflectedMethod GetKeyLocale;
 
         /// <summary>The language codes used in asset keys.</summary>
         private readonly IDictionary<string, LanguageCode> KeyLocales;
@@ -101,7 +101,7 @@ namespace StardewModdingAPI.Framework
             // init
             this.Monitor = monitor ?? throw new ArgumentNullException(nameof(monitor));
             this.Cache = new ContentCache(this, reflection, SContentManager.PossiblePathSeparators, SContentManager.PreferredPathSeparator);
-            this.GetKeyLocale = reflection.GetPrivateMethod(this, "languageCode");
+            this.GetKeyLocale = reflection.GetMethod(this, "languageCode");
             this.ModContentPrefix = this.GetAssetNameFromFilePath(Constants.ModPath);
 
             // get asset data
@@ -205,7 +205,7 @@ namespace StardewModdingAPI.Framework
                 return this.LoadImpl<T>(assetName, instance);
 
             // load mod content
-            SContentLoadException GetContentError(string reasonPhrase) => new SContentLoadException($"Failed loading content asset '{assetName}': {reasonPhrase}.");
+            SContentLoadException GetContentError(string reasonPhrase) => new SContentLoadException($"Failed loading content asset '{assetName}': {reasonPhrase}");
             try
             {
                 return this.WithWriteLock(() =>
@@ -252,6 +252,8 @@ namespace StardewModdingAPI.Framework
             }
             catch (Exception ex) when (!(ex is SContentLoadException))
             {
+                if (ex.GetInnermostException() is DllNotFoundException dllEx && dllEx.Message == "libgdiplus.dylib")
+                    throw GetContentError("couldn't find libgdiplus, which is needed to load mod images. Make sure Mono is installed and you're running the game through the normal launcher.");
                 throw new SContentLoadException($"The content manager failed loading content asset '{assetName}'.", ex);
             }
         }
@@ -413,7 +415,7 @@ namespace StardewModdingAPI.Framework
         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");
+            IReflectedField<LanguageCode> codeField = reflection.GetField<LanguageCode>(typeof(LocalizedContentManager), "_currentLangCode");
 
             // remember previous settings
             LanguageCode previousCode = codeField.GetValue();
diff --git a/src/SMAPI/Framework/SGame.cs b/src/SMAPI/Framework/SGame.cs
index c886a4b7..0a614f17 100644
--- a/src/SMAPI/Framework/SGame.cs
+++ b/src/SMAPI/Framework/SGame.cs
@@ -133,20 +133,20 @@ namespace StardewModdingAPI.Framework
 
         // ReSharper disable ArrangeStaticMemberQualifier, ArrangeThisQualifier, InconsistentNaming
         /// <summary>Used to access private fields and methods.</summary>
-        private static List<float> _fpsList => SGame.Reflection.GetPrivateField<List<float>>(typeof(Game1), nameof(_fpsList)).GetValue();
-        private static Stopwatch _fpsStopwatch => SGame.Reflection.GetPrivateField<Stopwatch>(typeof(Game1), nameof(SGame._fpsStopwatch)).GetValue();
+        private static List<float> _fpsList => SGame.Reflection.GetField<List<float>>(typeof(Game1), nameof(_fpsList)).GetValue();
+        private static Stopwatch _fpsStopwatch => SGame.Reflection.GetField<Stopwatch>(typeof(Game1), nameof(SGame._fpsStopwatch)).GetValue();
         private static float _fps
         {
-            set => SGame.Reflection.GetPrivateField<float>(typeof(Game1), nameof(_fps)).SetValue(value);
+            set => SGame.Reflection.GetField<float>(typeof(Game1), nameof(_fps)).SetValue(value);
         }
-        private static Task _newDayTask => SGame.Reflection.GetPrivateField<Task>(typeof(Game1), nameof(_newDayTask)).GetValue();
-        private Color bgColor => SGame.Reflection.GetPrivateField<Color>(this, nameof(bgColor)).GetValue();
-        public RenderTarget2D screenWrapper => SGame.Reflection.GetPrivateProperty<RenderTarget2D>(this, "screen").GetValue(); // deliberately renamed to avoid an infinite loop
-        public BlendState lightingBlend => SGame.Reflection.GetPrivateField<BlendState>(this, nameof(lightingBlend)).GetValue();
-        private readonly Action drawFarmBuildings = () => SGame.Reflection.GetPrivateMethod(SGame.Instance, nameof(drawFarmBuildings)).Invoke();
-        private readonly Action drawHUD = () => SGame.Reflection.GetPrivateMethod(SGame.Instance, nameof(drawHUD)).Invoke();
-        private readonly Action drawDialogueBox = () => SGame.Reflection.GetPrivateMethod(SGame.Instance, nameof(drawDialogueBox)).Invoke();
-        private readonly Action renderScreenBuffer = () => SGame.Reflection.GetPrivateMethod(SGame.Instance, nameof(renderScreenBuffer)).Invoke();
+        private static Task _newDayTask => SGame.Reflection.GetField<Task>(typeof(Game1), nameof(_newDayTask)).GetValue();
+        private Color bgColor => SGame.Reflection.GetField<Color>(this, nameof(bgColor)).GetValue();
+        public RenderTarget2D screenWrapper => SGame.Reflection.GetProperty<RenderTarget2D>(this, "screen").GetValue(); // deliberately renamed to avoid an infinite loop
+        public BlendState lightingBlend => SGame.Reflection.GetField<BlendState>(this, nameof(lightingBlend)).GetValue();
+        private readonly Action drawFarmBuildings = () => SGame.Reflection.GetMethod(SGame.Instance, nameof(drawFarmBuildings)).Invoke();
+        private readonly Action drawHUD = () => SGame.Reflection.GetMethod(SGame.Instance, nameof(drawHUD)).Invoke();
+        private readonly Action drawDialogueBox = () => SGame.Reflection.GetMethod(SGame.Instance, nameof(drawDialogueBox)).Invoke();
+        private readonly Action renderScreenBuffer = () => SGame.Reflection.GetMethod(SGame.Instance, nameof(renderScreenBuffer)).Invoke();
         // ReSharper restore ArrangeStaticMemberQualifier, ArrangeThisQualifier, InconsistentNaming
 
 
@@ -182,7 +182,7 @@ namespace StardewModdingAPI.Framework
             this.SContentManager = new SContentManager(this.Content.ServiceProvider, this.Content.RootDirectory, Thread.CurrentThread.CurrentUICulture, null, this.Monitor, reflection);
             this.Content = new ContentManagerShim(this.SContentManager, "SGame.Content");
             Game1.content = new ContentManagerShim(this.SContentManager, "Game1.content");
-            reflection.GetPrivateField<LocalizedContentManager>(typeof(Game1), "_temporaryContent").SetValue(new ContentManagerShim(this.SContentManager, "Game1._temporaryContent")); // regenerate value with new content manager
+            reflection.GetField<LocalizedContentManager>(typeof(Game1), "_temporaryContent").SetValue(new ContentManagerShim(this.SContentManager, "Game1._temporaryContent")); // regenerate value with new content manager
         }
 
         /****
@@ -557,9 +557,12 @@ namespace StardewModdingAPI.Framework
                 /*********
                 ** Update events
                 *********/
-                GameEvents.InvokeUpdateTick(this.Monitor);
                 if (this.FirstUpdate)
+                {
                     this.FirstUpdate = false;
+                    GameEvents.InvokeFirstUpdateTick(this.Monitor);
+                }
+                GameEvents.InvokeUpdateTick(this.Monitor);
                 if (this.CurrentUpdateTick % 2 == 0)
                     GameEvents.InvokeSecondUpdateTick(this.Monitor);
                 if (this.CurrentUpdateTick % 4 == 0)
@@ -689,6 +692,7 @@ namespace StardewModdingAPI.Framework
                             this.Monitor.Log($"The {activeClickableMenu.GetType().FullName} menu crashed while drawing itself during save. SMAPI will force it to exit to avoid crashing the game.\n{ex.GetLogSummary()}", LogLevel.Error);
                             activeClickableMenu.exitThisMenu();
                         }
+                        this.RaisePostRender();
                         Game1.spriteBatch.End();
                     }
                     //base.Draw(gameTime);
@@ -712,6 +716,7 @@ namespace StardewModdingAPI.Framework
                             this.Monitor.Log($"The {Game1.activeClickableMenu.GetType().FullName} menu crashed while drawing itself. SMAPI will force it to exit to avoid crashing the game.\n{ex.GetLogSummary()}", LogLevel.Error);
                             Game1.activeClickableMenu.exitThisMenu();
                         }
+                        this.RaisePostRender();
                         Game1.spriteBatch.End();
                         if ((double)Game1.options.zoomLevel != 1.0)
                         {
@@ -721,11 +726,12 @@ namespace StardewModdingAPI.Framework
                             Game1.spriteBatch.Draw((Texture2D)this.screenWrapper, Vector2.Zero, new Microsoft.Xna.Framework.Rectangle?(this.screenWrapper.Bounds), Color.White, 0.0f, Vector2.Zero, Game1.options.zoomLevel, SpriteEffects.None, 1f);
                             Game1.spriteBatch.End();
                         }
-                        if (Game1.overlayMenu == null)
-                            return;
-                        Game1.spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerState.PointClamp, (DepthStencilState)null, (RasterizerState)null);
-                        Game1.overlayMenu.draw(Game1.spriteBatch);
-                        Game1.spriteBatch.End();
+                        if (Game1.overlayMenu != null)
+                        {
+                            Game1.spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerState.PointClamp, (DepthStencilState)null, (RasterizerState)null);
+                            Game1.overlayMenu.draw(Game1.spriteBatch);
+                            Game1.spriteBatch.End();
+                        }
                     }
                     else if ((int)Game1.gameMode == 11)
                     {
@@ -733,6 +739,7 @@ namespace StardewModdingAPI.Framework
                         Game1.spriteBatch.DrawString(Game1.dialogueFont, Game1.content.LoadString("Strings\\StringsFromCSFiles:Game1.cs.3685"), new Vector2(16f, 16f), Color.HotPink);
                         Game1.spriteBatch.DrawString(Game1.dialogueFont, Game1.content.LoadString("Strings\\StringsFromCSFiles:Game1.cs.3686"), new Vector2(16f, 32f), new Color(0, (int)byte.MaxValue, 0));
                         Game1.spriteBatch.DrawString(Game1.dialogueFont, Game1.parseText(Game1.errorMessage, Game1.dialogueFont, Game1.graphics.GraphicsDevice.Viewport.Width), new Vector2(16f, 48f), Color.White);
+                        this.RaisePostRender();
                         Game1.spriteBatch.End();
                     }
                     else if (Game1.currentMinigame != null)
@@ -744,6 +751,7 @@ namespace StardewModdingAPI.Framework
                             Game1.spriteBatch.Draw(Game1.fadeToBlackRect, Game1.graphics.GraphicsDevice.Viewport.Bounds, Color.Black * ((int)Game1.gameMode == 0 ? 1f - Game1.fadeToBlackAlpha : Game1.fadeToBlackAlpha));
                             Game1.spriteBatch.End();
                         }
+                        this.RaisePostRender(needsNewBatch: true);
                         if ((double)Game1.options.zoomLevel != 1.0)
                         {
                             this.GraphicsDevice.SetRenderTarget((RenderTarget2D)null);
@@ -752,11 +760,12 @@ namespace StardewModdingAPI.Framework
                             Game1.spriteBatch.Draw((Texture2D)this.screenWrapper, Vector2.Zero, new Microsoft.Xna.Framework.Rectangle?(this.screenWrapper.Bounds), Color.White, 0.0f, Vector2.Zero, Game1.options.zoomLevel, SpriteEffects.None, 1f);
                             Game1.spriteBatch.End();
                         }
-                        if (Game1.overlayMenu == null)
-                            return;
-                        Game1.spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerState.PointClamp, (DepthStencilState)null, (RasterizerState)null);
-                        Game1.overlayMenu.draw(Game1.spriteBatch);
-                        Game1.spriteBatch.End();
+                        if (Game1.overlayMenu != null)
+                        {
+                            Game1.spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerState.PointClamp, (DepthStencilState)null, (RasterizerState)null);
+                            Game1.overlayMenu.draw(Game1.spriteBatch);
+                            Game1.spriteBatch.End();
+                        }
                     }
                     else if (Game1.showingEndOfNightStuff)
                     {
@@ -775,6 +784,7 @@ namespace StardewModdingAPI.Framework
                                 Game1.activeClickableMenu.exitThisMenu();
                             }
                         }
+                        this.RaisePostRender();
                         Game1.spriteBatch.End();
                         if ((double)Game1.options.zoomLevel != 1.0)
                         {
@@ -784,11 +794,12 @@ namespace StardewModdingAPI.Framework
                             Game1.spriteBatch.Draw((Texture2D)this.screenWrapper, Vector2.Zero, new Microsoft.Xna.Framework.Rectangle?(this.screenWrapper.Bounds), Color.White, 0.0f, Vector2.Zero, Game1.options.zoomLevel, SpriteEffects.None, 1f);
                             Game1.spriteBatch.End();
                         }
-                        if (Game1.overlayMenu == null)
-                            return;
-                        Game1.spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerState.PointClamp, (DepthStencilState)null, (RasterizerState)null);
-                        Game1.overlayMenu.draw(Game1.spriteBatch);
-                        Game1.spriteBatch.End();
+                        if (Game1.overlayMenu != null)
+                        {
+                            Game1.spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerState.PointClamp, (DepthStencilState)null, (RasterizerState)null);
+                            Game1.overlayMenu.draw(Game1.spriteBatch);
+                            Game1.spriteBatch.End();
+                        }
                     }
                     else if ((int)Game1.gameMode == 6)
                     {
@@ -806,6 +817,7 @@ namespace StardewModdingAPI.Framework
                         int x = 64;
                         int y = Game1.graphics.GraphicsDevice.Viewport.TitleSafeArea.Bottom - height;
                         SpriteText.drawString(Game1.spriteBatch, s, x, y, 999999, widthOfString, height, 1f, 0.88f, false, 0, str5, -1);
+                        this.RaisePostRender();
                         Game1.spriteBatch.End();
                         if ((double)Game1.options.zoomLevel != 1.0)
                         {
@@ -815,11 +827,12 @@ namespace StardewModdingAPI.Framework
                             Game1.spriteBatch.Draw((Texture2D)this.screenWrapper, Vector2.Zero, new Microsoft.Xna.Framework.Rectangle?(this.screenWrapper.Bounds), Color.White, 0.0f, Vector2.Zero, Game1.options.zoomLevel, SpriteEffects.None, 1f);
                             Game1.spriteBatch.End();
                         }
-                        if (Game1.overlayMenu == null)
-                            return;
-                        Game1.spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerState.PointClamp, (DepthStencilState)null, (RasterizerState)null);
-                        Game1.overlayMenu.draw(Game1.spriteBatch);
-                        Game1.spriteBatch.End();
+                        if (Game1.overlayMenu != null)
+                        {
+                            Game1.spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerState.PointClamp, (DepthStencilState)null, (RasterizerState)null);
+                            Game1.overlayMenu.draw(Game1.spriteBatch);
+                            Game1.spriteBatch.End();
+                        }
                     }
                     else
                     {
@@ -1265,6 +1278,8 @@ namespace StardewModdingAPI.Framework
                         }
                         else if (Game1.farmEvent != null)
                             Game1.farmEvent.drawAboveEverything(Game1.spriteBatch);
+
+                        this.RaisePostRender();
                         Game1.spriteBatch.End();
                         if (Game1.overlayMenu != null)
                         {
@@ -1272,14 +1287,6 @@ namespace StardewModdingAPI.Framework
                             Game1.overlayMenu.draw(Game1.spriteBatch);
                             Game1.spriteBatch.End();
                         }
-
-                        if (GraphicsEvents.HasPostRenderListeners())
-                        {
-                            Game1.spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerState.PointClamp, null, null);
-                            GraphicsEvents.InvokeOnPostRenderEvent(this.Monitor);
-                            Game1.spriteBatch.End();
-                        }
-
                         this.renderScreenBuffer();
                     }
                 }
@@ -1401,5 +1408,19 @@ namespace StardewModdingAPI.Framework
                 hash ^= v.GetHashCode();
             return hash;
         }
+
+        /// <summary>Raise the <see cref="GraphicsEvents.OnPostRenderEvent"/> if there are any listeners.</summary>
+        /// <param name="needsNewBatch">Whether to create a new sprite batch.</param>
+        private void RaisePostRender(bool needsNewBatch = false)
+        {
+            if (GraphicsEvents.HasPostRenderListeners())
+            {
+                if (needsNewBatch)
+                    Game1.spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerState.PointClamp, null, null);
+                GraphicsEvents.InvokeOnPostRenderEvent(this.Monitor);
+                if (needsNewBatch)
+                    Game1.spriteBatch.End();
+            }
+        }
     }
 }