move error-handling Harmony patches into a new Error Handler bundled mod

5 files changed, 720 insertions, 0 deletions

diff --git a/src/SMAPI.Mods.ErrorHandler/Patches/DialogueErrorPatch.cs b/src/SMAPI.Mods.ErrorHandler/Patches/DialogueErrorPatch.cs
new file mode 100644
index 00000000..ba0ca582
--- /dev/null
+++ b/src/SMAPI.Mods.ErrorHandler/Patches/DialogueErrorPatch.cs
@@ -0,0 +1,191 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using StardewModdingAPI.Framework.Patching;
+using StardewValley;
+#if HARMONY_2
+using HarmonyLib;
+using StardewModdingAPI.Framework;
+#else
+using System.Reflection;
+using Harmony;
+#endif
+
+namespace StardewModdingAPI.Mods.ErrorHandler.Patches
+{
+    /// <summary>A Harmony patch for the <see cref="Dialogue"/> constructor which intercepts invalid dialogue lines and logs an error instead of crashing.</summary>
+    /// <remarks>Patch methods must be static for Harmony to work correctly. See the Harmony documentation before renaming patch arguments.</remarks>
+    [SuppressMessage("ReSharper", "InconsistentNaming", Justification = "Argument names are defined by Harmony and methods are named for clarity.")]
+    [SuppressMessage("ReSharper", "IdentifierTypo", Justification = "Argument names are defined by Harmony and methods are named for clarity.")]
+    internal class DialogueErrorPatch : IHarmonyPatch
+    {
+        /*********
+        ** Fields
+        *********/
+        /// <summary>Writes messages to the console and log file on behalf of the game.</summary>
+        private static IMonitor MonitorForGame;
+
+        /// <summary>Simplifies access to private code.</summary>
+        private static IReflectionHelper Reflection;
+
+
+        /*********
+        ** Accessors
+        *********/
+        /// <inheritdoc />
+        public string Name => nameof(DialogueErrorPatch);
+
+
+        /*********
+        ** Public methods
+        *********/
+        /// <summary>Construct an instance.</summary>
+        /// <param name="monitorForGame">Writes messages to the console and log file on behalf of the game.</param>
+        /// <param name="reflector">Simplifies access to private code.</param>
+        public DialogueErrorPatch(IMonitor monitorForGame, IReflectionHelper reflector)
+        {
+            DialogueErrorPatch.MonitorForGame = monitorForGame;
+            DialogueErrorPatch.Reflection = reflector;
+        }
+
+
+        /// <inheritdoc />
+#if HARMONY_2
+        public void Apply(Harmony harmony)
+        {
+            harmony.Patch(
+                original: AccessTools.Constructor(typeof(Dialogue), new[] { typeof(string), typeof(NPC) }),
+                finalizer: new HarmonyMethod(this.GetType(), nameof(DialogueErrorPatch.Finalize_Dialogue_Constructor))
+            );
+            harmony.Patch(
+                original: AccessTools.Property(typeof(NPC), nameof(NPC.CurrentDialogue)).GetMethod,
+                finalizer: new HarmonyMethod(this.GetType(), nameof(DialogueErrorPatch.Finalize_NPC_CurrentDialogue))
+            );
+        }
+#else
+        public void Apply(HarmonyInstance harmony)
+        {
+            harmony.Patch(
+                original: AccessTools.Constructor(typeof(Dialogue), new[] { typeof(string), typeof(NPC) }),
+                prefix: new HarmonyMethod(this.GetType(), nameof(DialogueErrorPatch.Before_Dialogue_Constructor))
+            );
+            harmony.Patch(
+                original: AccessTools.Property(typeof(NPC), nameof(NPC.CurrentDialogue)).GetMethod,
+                prefix: new HarmonyMethod(this.GetType(), nameof(DialogueErrorPatch.Before_NPC_CurrentDialogue))
+            );
+        }
+#endif
+
+
+        /*********
+        ** Private methods
+        *********/
+#if HARMONY_2
+        /// <summary>The method to call after the Dialogue constructor.</summary>
+        /// <param name="__instance">The instance being patched.</param>
+        /// <param name="masterDialogue">The dialogue being parsed.</param>
+        /// <param name="speaker">The NPC for which the dialogue is being parsed.</param>
+        /// <param name="__exception">The exception thrown by the wrapped method, if any.</param>
+        /// <returns>Returns the exception to throw, if any.</returns>
+        private static Exception Finalize_Dialogue_Constructor(Dialogue __instance, string masterDialogue, NPC speaker, Exception __exception)
+        {
+            if (__exception != null)
+            {
+                // log message
+                string name = !string.IsNullOrWhiteSpace(speaker?.Name) ? speaker.Name : null;
+                DialogueErrorPatch.MonitorForGame.Log($"Failed parsing dialogue string{(name != null ? $" for {name}" : "")}:\n{masterDialogue}\n{__exception.GetLogSummary()}", LogLevel.Error);
+
+                // set default dialogue
+                IReflectedMethod parseDialogueString = DialogueErrorPatch.Reflection.GetMethod(__instance, "parseDialogueString");
+                IReflectedMethod checkForSpecialDialogueAttributes = DialogueErrorPatch.Reflection.GetMethod(__instance, "checkForSpecialDialogueAttributes");
+                parseDialogueString.Invoke("...");
+                checkForSpecialDialogueAttributes.Invoke();
+            }
+
+            return null;
+        }
+
+        /// <summary>The method to call after <see cref="NPC.CurrentDialogue"/>.</summary>
+        /// <param name="__instance">The instance being patched.</param>
+        /// <param name="__result">The return value of the original method.</param>
+        /// <param name="__exception">The exception thrown by the wrapped method, if any.</param>
+        /// <returns>Returns the exception to throw, if any.</returns>
+        private static Exception Finalize_NPC_CurrentDialogue(NPC __instance, ref Stack<Dialogue> __result, Exception __exception)
+        {
+            if (__exception == null)
+                return null;
+
+            DialogueErrorPatch.MonitorForGame.Log($"Failed loading current dialogue for NPC {__instance.Name}:\n{__exception.GetLogSummary()}", LogLevel.Error);
+            __result = new Stack<Dialogue>();
+
+            return null;
+        }
+#else
+
+        /// <summary>The method to call instead of the Dialogue constructor.</summary>
+        /// <param name="__instance">The instance being patched.</param>
+        /// <param name="masterDialogue">The dialogue being parsed.</param>
+        /// <param name="speaker">The NPC for which the dialogue is being parsed.</param>
+        /// <returns>Returns whether to execute the original method.</returns>
+        private static bool Before_Dialogue_Constructor(Dialogue __instance, string masterDialogue, NPC speaker)
+        {
+            // get private members
+            bool nameArraysTranslated = DialogueErrorPatch.Reflection.GetField<bool>(typeof(Dialogue), "nameArraysTranslated").GetValue();
+            IReflectedMethod translateArraysOfStrings = DialogueErrorPatch.Reflection.GetMethod(typeof(Dialogue), "TranslateArraysOfStrings");
+            IReflectedMethod parseDialogueString = DialogueErrorPatch.Reflection.GetMethod(__instance, "parseDialogueString");
+            IReflectedMethod checkForSpecialDialogueAttributes = DialogueErrorPatch.Reflection.GetMethod(__instance, "checkForSpecialDialogueAttributes");
+
+            // replicate base constructor
+            __instance.dialogues ??= new List<string>();
+
+            // duplicate code with try..catch
+            try
+            {
+                if (!nameArraysTranslated)
+                    translateArraysOfStrings.Invoke();
+                __instance.speaker = speaker;
+                parseDialogueString.Invoke(masterDialogue);
+                checkForSpecialDialogueAttributes.Invoke();
+            }
+            catch (Exception baseEx) when (baseEx.InnerException is TargetInvocationException invocationEx && invocationEx.InnerException is Exception ex)
+            {
+                string name = !string.IsNullOrWhiteSpace(speaker?.Name) ? speaker.Name : null;
+                DialogueErrorPatch.MonitorForGame.Log($"Failed parsing dialogue string{(name != null ? $" for {name}" : "")}:\n{masterDialogue}\n{ex}", LogLevel.Error);
+
+                parseDialogueString.Invoke("...");
+                checkForSpecialDialogueAttributes.Invoke();
+            }
+
+            return false;
+        }
+
+        /// <summary>The method to call instead of <see cref="NPC.CurrentDialogue"/>.</summary>
+        /// <param name="__instance">The instance being patched.</param>
+        /// <param name="__result">The return value of the original method.</param>
+        /// <param name="__originalMethod">The method being wrapped.</param>
+        /// <returns>Returns whether to execute the original method.</returns>
+        private static bool Before_NPC_CurrentDialogue(NPC __instance, ref Stack<Dialogue> __result, MethodInfo __originalMethod)
+        {
+            const string key = nameof(DialogueErrorPatch.Before_NPC_CurrentDialogue);
+            if (!PatchHelper.StartIntercept(key))
+                return true;
+
+            try
+            {
+                __result = (Stack<Dialogue>)__originalMethod.Invoke(__instance, new object[0]);
+                return false;
+            }
+            catch (TargetInvocationException ex)
+            {
+                DialogueErrorPatch.MonitorForGame.Log($"Failed loading current dialogue for NPC {__instance.Name}:\n{ex.InnerException ?? ex}", LogLevel.Error);
+                __result = new Stack<Dialogue>();
+                return false;
+            }
+            finally
+            {
+                PatchHelper.StopIntercept(key);
+            }
+        }
+#endif
+    }
+}
diff --git a/src/SMAPI.Mods.ErrorHandler/Patches/EventErrorPatch.cs b/src/SMAPI.Mods.ErrorHandler/Patches/EventErrorPatch.cs
new file mode 100644
index 00000000..fabc6cad
--- /dev/null
+++ b/src/SMAPI.Mods.ErrorHandler/Patches/EventErrorPatch.cs
@@ -0,0 +1,114 @@
+using System.Diagnostics.CodeAnalysis;
+#if HARMONY_2
+using System;
+using HarmonyLib;
+#else
+using System.Reflection;
+using Harmony;
+#endif
+using StardewModdingAPI.Framework.Patching;
+using StardewValley;
+
+namespace StardewModdingAPI.Mods.ErrorHandler.Patches
+{
+    /// <summary>A Harmony patch for <see cref="GameLocation.checkEventPrecondition"/> which intercepts invalid preconditions and logs an error instead of crashing.</summary>
+    /// <remarks>Patch methods must be static for Harmony to work correctly. See the Harmony documentation before renaming patch arguments.</remarks>
+    [SuppressMessage("ReSharper", "InconsistentNaming", Justification = "Argument names are defined by Harmony and methods are named for clarity.")]
+    [SuppressMessage("ReSharper", "IdentifierTypo", Justification = "Argument names are defined by Harmony and methods are named for clarity.")]
+    internal class EventErrorPatch : IHarmonyPatch
+    {
+        /*********
+        ** Fields
+        *********/
+        /// <summary>Writes messages to the console and log file on behalf of the game.</summary>
+        private static IMonitor MonitorForGame;
+
+
+        /*********
+        ** Accessors
+        *********/
+        /// <inheritdoc />
+        public string Name => nameof(EventErrorPatch);
+
+
+        /*********
+        ** Public methods
+        *********/
+        /// <summary>Construct an instance.</summary>
+        /// <param name="monitorForGame">Writes messages to the console and log file on behalf of the game.</param>
+        public EventErrorPatch(IMonitor monitorForGame)
+        {
+            EventErrorPatch.MonitorForGame = monitorForGame;
+        }
+
+        /// <inheritdoc />
+#if HARMONY_2
+        public void Apply(Harmony harmony)
+        {
+            harmony.Patch(
+                original: AccessTools.Method(typeof(GameLocation), "checkEventPrecondition"),
+                finalizer: new HarmonyMethod(this.GetType(), nameof(EventErrorPatch.Finalize_GameLocation_CheckEventPrecondition))
+            );
+        }
+#else
+        public void Apply(HarmonyInstance harmony)
+        {
+            harmony.Patch(
+                original: AccessTools.Method(typeof(GameLocation), "checkEventPrecondition"),
+                prefix: new HarmonyMethod(this.GetType(), nameof(EventErrorPatch.Before_GameLocation_CheckEventPrecondition))
+            );
+        }
+#endif
+
+
+        /*********
+        ** Private methods
+        *********/
+#if HARMONY_2
+        /// <summary>The method to call instead of GameLocation.checkEventPrecondition.</summary>
+        /// <param name="__result">The return value of the original method.</param>
+        /// <param name="precondition">The precondition to be parsed.</param>
+        /// <param name="__exception">The exception thrown by the wrapped method, if any.</param>
+        /// <returns>Returns the exception to throw, if any.</returns>
+        private static Exception Finalize_GameLocation_CheckEventPrecondition(ref int __result, string precondition, Exception __exception)
+        {
+            if (__exception != null)
+            {
+                __result = -1;
+                EventErrorPatch.MonitorForGame.Log($"Failed parsing event precondition ({precondition}):\n{__exception.InnerException}", LogLevel.Error);
+            }
+
+            return null;
+        }
+#else
+        /// <summary>The method to call instead of GameLocation.checkEventPrecondition.</summary>
+        /// <param name="__instance">The instance being patched.</param>
+        /// <param name="__result">The return value of the original method.</param>
+        /// <param name="precondition">The precondition to be parsed.</param>
+        /// <param name="__originalMethod">The method being wrapped.</param>
+        /// <returns>Returns whether to execute the original method.</returns>
+        private static bool Before_GameLocation_CheckEventPrecondition(GameLocation __instance, ref int __result, string precondition, MethodInfo __originalMethod)
+        {
+            const string key = nameof(EventErrorPatch.Before_GameLocation_CheckEventPrecondition);
+            if (!PatchHelper.StartIntercept(key))
+                return true;
+
+            try
+            {
+                __result = (int)__originalMethod.Invoke(__instance, new object[] { precondition });
+                return false;
+            }
+            catch (TargetInvocationException ex)
+            {
+                __result = -1;
+                EventErrorPatch.MonitorForGame.Log($"Failed parsing event precondition ({precondition}):\n{ex.InnerException}", LogLevel.Error);
+                return false;
+            }
+            finally
+            {
+                PatchHelper.StopIntercept(key);
+            }
+        }
+#endif
+    }
+}
diff --git a/src/SMAPI.Mods.ErrorHandler/Patches/LoadErrorPatch.cs b/src/SMAPI.Mods.ErrorHandler/Patches/LoadErrorPatch.cs
new file mode 100644
index 00000000..2227ea07
--- /dev/null
+++ b/src/SMAPI.Mods.ErrorHandler/Patches/LoadErrorPatch.cs
@@ -0,0 +1,157 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+#if HARMONY_2
+using HarmonyLib;
+#else
+using Harmony;
+#endif
+using StardewModdingAPI.Framework.Exceptions;
+using StardewModdingAPI.Framework.Patching;
+using StardewValley;
+using StardewValley.Buildings;
+using StardewValley.Locations;
+
+namespace StardewModdingAPI.Mods.ErrorHandler.Patches
+{
+    /// <summary>A Harmony patch for <see cref="SaveGame"/> which prevents some errors due to broken save data.</summary>
+    /// <remarks>Patch methods must be static for Harmony to work correctly. See the Harmony documentation before renaming patch arguments.</remarks>
+    [SuppressMessage("ReSharper", "InconsistentNaming", Justification = "Argument names are defined by Harmony and methods are named for clarity.")]
+    [SuppressMessage("ReSharper", "IdentifierTypo", Justification = "Argument names are defined by Harmony and methods are named for clarity.")]
+    internal class LoadErrorPatch : IHarmonyPatch
+    {
+        /*********
+        ** Fields
+        *********/
+        /// <summary>Writes messages to the console and log file.</summary>
+        private static IMonitor Monitor;
+
+        /// <summary>A callback invoked when custom content is removed from the save data to avoid a crash.</summary>
+        private static Action OnContentRemoved;
+
+
+        /*********
+        ** Accessors
+        *********/
+        /// <inheritdoc />
+        public string Name => nameof(LoadErrorPatch);
+
+
+        /*********
+        ** Public methods
+        *********/
+        /// <summary>Construct an instance.</summary>
+        /// <param name="monitor">Writes messages to the console and log file.</param>
+        /// <param name="onContentRemoved">A callback invoked when custom content is removed from the save data to avoid a crash.</param>
+        public LoadErrorPatch(IMonitor monitor, Action onContentRemoved)
+        {
+            LoadErrorPatch.Monitor = monitor;
+            LoadErrorPatch.OnContentRemoved = onContentRemoved;
+        }
+
+
+        /// <inheritdoc />
+#if HARMONY_2
+        public void Apply(Harmony harmony)
+#else
+        public void Apply(HarmonyInstance harmony)
+#endif
+        {
+            harmony.Patch(
+                original: AccessTools.Method(typeof(SaveGame), nameof(SaveGame.loadDataToLocations)),
+                prefix: new HarmonyMethod(this.GetType(), nameof(LoadErrorPatch.Before_SaveGame_LoadDataToLocations))
+            );
+        }
+
+
+        /*********
+        ** Private methods
+        *********/
+        /// <summary>The method to call instead of <see cref="SaveGame.loadDataToLocations"/>.</summary>
+        /// <param name="gamelocations">The game locations being loaded.</param>
+        /// <returns>Returns whether to execute the original method.</returns>
+        private static bool Before_SaveGame_LoadDataToLocations(List<GameLocation> gamelocations)
+        {
+            bool removedAny =
+                LoadErrorPatch.RemoveBrokenBuildings(gamelocations)
+                | LoadErrorPatch.RemoveInvalidNpcs(gamelocations);
+
+            if (removedAny)
+                LoadErrorPatch.OnContentRemoved();
+
+            return true;
+        }
+
+        /// <summary>Remove buildings which don't exist in the game data.</summary>
+        /// <param name="locations">The current game locations.</param>
+        private static bool RemoveBrokenBuildings(IEnumerable<GameLocation> locations)
+        {
+            bool removedAny = false;
+
+            foreach (BuildableGameLocation location in locations.OfType<BuildableGameLocation>())
+            {
+                foreach (Building building in location.buildings.ToArray())
+                {
+                    try
+                    {
+                        BluePrint _ = new BluePrint(building.buildingType.Value);
+                    }
+                    catch (SContentLoadException)
+                    {
+                        LoadErrorPatch.Monitor.Log($"Removed invalid building type '{building.buildingType.Value}' in {location.Name} ({building.tileX}, {building.tileY}) to avoid a crash when loading save '{Constants.SaveFolderName}'. (Did you remove a custom building mod?)", LogLevel.Warn);
+                        location.buildings.Remove(building);
+                        removedAny = true;
+                    }
+                }
+            }
+
+            return removedAny;
+        }
+
+        /// <summary>Remove NPCs which don't exist in the game data.</summary>
+        /// <param name="locations">The current game locations.</param>
+        private static bool RemoveInvalidNpcs(IEnumerable<GameLocation> locations)
+        {
+            bool removedAny = false;
+
+            IDictionary<string, string> data = Game1.content.Load<Dictionary<string, string>>("Data\\NPCDispositions");
+            foreach (GameLocation location in LoadErrorPatch.GetAllLocations(locations))
+            {
+                foreach (NPC npc in location.characters.ToArray())
+                {
+                    if (npc.isVillager() && !data.ContainsKey(npc.Name))
+                    {
+                        try
+                        {
+                            npc.reloadSprite(); // this won't crash for special villagers like Bouncer
+                        }
+                        catch
+                        {
+                            LoadErrorPatch.Monitor.Log($"Removed invalid villager '{npc.Name}' in {location.Name} ({npc.getTileLocation()}) to avoid a crash when loading save '{Constants.SaveFolderName}'. (Did you remove a custom NPC mod?)", LogLevel.Warn);
+                            location.characters.Remove(npc);
+                            removedAny = true;
+                        }
+                    }
+                }
+            }
+
+            return removedAny;
+        }
+
+        /// <summary>Get all locations, including building interiors.</summary>
+        /// <param name="locations">The main game locations.</param>
+        private static IEnumerable<GameLocation> GetAllLocations(IEnumerable<GameLocation> locations)
+        {
+            foreach (GameLocation location in locations)
+            {
+                yield return location;
+                if (location is BuildableGameLocation buildableLocation)
+                {
+                    foreach (GameLocation interior in buildableLocation.buildings.Select(p => p.indoors.Value).Where(p => p != null))
+                        yield return interior;
+                }
+            }
+        }
+    }
+}
diff --git a/src/SMAPI.Mods.ErrorHandler/Patches/ObjectErrorPatch.cs b/src/SMAPI.Mods.ErrorHandler/Patches/ObjectErrorPatch.cs
new file mode 100644
index 00000000..70f054cd
--- /dev/null
+++ b/src/SMAPI.Mods.ErrorHandler/Patches/ObjectErrorPatch.cs
@@ -0,0 +1,143 @@
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using StardewModdingAPI.Framework.Patching;
+using StardewValley;
+using StardewValley.Menus;
+using SObject = StardewValley.Object;
+#if HARMONY_2
+using System;
+using HarmonyLib;
+#else
+using System.Reflection;
+using Harmony;
+#endif
+
+namespace StardewModdingAPI.Mods.ErrorHandler.Patches
+{
+    /// <summary>A Harmony patch for <see cref="SObject.getDescription"/> which intercepts crashes due to the item no longer existing.</summary>
+    /// <remarks>Patch methods must be static for Harmony to work correctly. See the Harmony documentation before renaming patch arguments.</remarks>
+    [SuppressMessage("ReSharper", "InconsistentNaming", Justification = "Argument names are defined by Harmony and methods are named for clarity.")]
+    [SuppressMessage("ReSharper", "IdentifierTypo", Justification = "Argument names are defined by Harmony and methods are named for clarity.")]
+    internal class ObjectErrorPatch : IHarmonyPatch
+    {
+        /*********
+        ** Accessors
+        *********/
+        /// <inheritdoc />
+        public string Name => nameof(ObjectErrorPatch);
+
+
+        /*********
+        ** Public methods
+        *********/
+        /// <inheritdoc />
+#if HARMONY_2
+        public void Apply(Harmony harmony)
+#else
+        public void Apply(HarmonyInstance harmony)
+#endif
+        {
+            // object.getDescription
+            harmony.Patch(
+                original: AccessTools.Method(typeof(SObject), nameof(SObject.getDescription)),
+                prefix: new HarmonyMethod(this.GetType(), nameof(ObjectErrorPatch.Before_Object_GetDescription))
+            );
+
+            // object.getDisplayName
+            harmony.Patch(
+                original: AccessTools.Method(typeof(SObject), "loadDisplayName"),
+#if HARMONY_2
+                finalizer: new HarmonyMethod(this.GetType(), nameof(ObjectErrorPatch.Finalize_Object_loadDisplayName))
+#else
+                prefix: new HarmonyMethod(this.GetType(), nameof(ObjectErrorPatch.Before_Object_loadDisplayName))
+#endif
+            );
+
+            // IClickableMenu.drawToolTip
+            harmony.Patch(
+                original: AccessTools.Method(typeof(IClickableMenu), nameof(IClickableMenu.drawToolTip)),
+                prefix: new HarmonyMethod(this.GetType(), nameof(ObjectErrorPatch.Before_IClickableMenu_DrawTooltip))
+            );
+        }
+
+
+        /*********
+        ** Private methods
+        *********/
+        /// <summary>The method to call instead of <see cref="StardewValley.Object.getDescription"/>.</summary>
+        /// <param name="__instance">The instance being patched.</param>
+        /// <param name="__result">The patched method's return value.</param>
+        /// <returns>Returns whether to execute the original method.</returns>
+        private static bool Before_Object_GetDescription(SObject __instance, ref string __result)
+        {
+            // invalid bigcraftables crash instead of showing '???' like invalid non-bigcraftables
+            if (!__instance.IsRecipe && __instance.bigCraftable.Value && !Game1.bigCraftablesInformation.ContainsKey(__instance.ParentSheetIndex))
+            {
+                __result = "???";
+                return false;
+            }
+
+            return true;
+        }
+
+#if HARMONY_2
+        /// <summary>The method to call after <see cref="StardewValley.Object.loadDisplayName"/>.</summary>
+        /// <param name="__result">The patched method's return value.</param>
+        /// <param name="__exception">The exception thrown by the wrapped method, if any.</param>
+        /// <returns>Returns the exception to throw, if any.</returns>
+        private static Exception Finalize_Object_loadDisplayName(ref string __result, Exception __exception)
+        {
+            if (__exception is KeyNotFoundException)
+            {
+                __result = "???";
+                return null;
+            }
+
+            return __exception;
+        }
+#else
+        /// <summary>The method to call instead of <see cref="StardewValley.Object.loadDisplayName"/>.</summary>
+        /// <param name="__instance">The instance being patched.</param>
+        /// <param name="__result">The patched method's return value.</param>
+        /// <param name="__originalMethod">The method being wrapped.</param>
+        /// <returns>Returns whether to execute the original method.</returns>
+        private static bool Before_Object_loadDisplayName(SObject __instance, ref string __result, MethodInfo __originalMethod)
+        {
+            const string key = nameof(ObjectErrorPatch.Before_Object_loadDisplayName);
+            if (!PatchHelper.StartIntercept(key))
+                return true;
+
+            try
+            {
+                __result = (string)__originalMethod.Invoke(__instance, new object[0]);
+                return false;
+            }
+            catch (TargetInvocationException ex) when (ex.InnerException is KeyNotFoundException)
+            {
+                __result = "???";
+                return false;
+            }
+            catch
+            {
+                return true;
+            }
+            finally
+            {
+                PatchHelper.StopIntercept(key);
+            }
+        }
+#endif
+
+        /// <summary>The method to call instead of <see cref="IClickableMenu.drawToolTip"/>.</summary>
+        /// <param name="hoveredItem">The item for which to draw a tooltip.</param>
+        /// <returns>Returns whether to execute the original method.</returns>
+        private static bool Before_IClickableMenu_DrawTooltip(Item hoveredItem)
+        {
+            // invalid edible item cause crash when drawing tooltips
+            if (hoveredItem is SObject obj && obj.Edibility != -300 && !Game1.objectInformation.ContainsKey(obj.ParentSheetIndex))
+                return false;
+
+            return true;
+        }
+    }
+}
diff --git a/src/SMAPI.Mods.ErrorHandler/Patches/ScheduleErrorPatch.cs b/src/SMAPI.Mods.ErrorHandler/Patches/ScheduleErrorPatch.cs
new file mode 100644
index 00000000..abbd1a8f
--- /dev/null
+++ b/src/SMAPI.Mods.ErrorHandler/Patches/ScheduleErrorPatch.cs
@@ -0,0 +1,115 @@
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using StardewModdingAPI.Framework.Patching;
+using StardewValley;
+#if HARMONY_2
+using System;
+using HarmonyLib;
+using StardewModdingAPI.Framework;
+#else
+using System.Reflection;
+using Harmony;
+#endif
+
+namespace StardewModdingAPI.Mods.ErrorHandler.Patches
+{
+    /// <summary>A Harmony patch for <see cref="NPC.parseMasterSchedule"/> which intercepts crashes due to invalid schedule data.</summary>
+    /// <remarks>Patch methods must be static for Harmony to work correctly. See the Harmony documentation before renaming patch arguments.</remarks>
+    [SuppressMessage("ReSharper", "InconsistentNaming", Justification = "Argument names are defined by Harmony and methods are named for clarity.")]
+    [SuppressMessage("ReSharper", "IdentifierTypo", Justification = "Argument names are defined by Harmony and methods are named for clarity.")]
+    internal class ScheduleErrorPatch : IHarmonyPatch
+    {
+        /*********
+        ** Fields
+        *********/
+        /// <summary>Writes messages to the console and log file on behalf of the game.</summary>
+        private static IMonitor MonitorForGame;
+
+
+        /*********
+        ** Accessors
+        *********/
+        /// <inheritdoc />
+        public string Name => nameof(ScheduleErrorPatch);
+
+
+        /*********
+        ** Public methods
+        *********/
+        /// <summary>Construct an instance.</summary>
+        /// <param name="monitorForGame">Writes messages to the console and log file on behalf of the game.</param>
+        public ScheduleErrorPatch(IMonitor monitorForGame)
+        {
+            ScheduleErrorPatch.MonitorForGame = monitorForGame;
+        }
+
+        /// <inheritdoc />
+#if HARMONY_2
+        public void Apply(Harmony harmony)
+#else
+        public void Apply(HarmonyInstance harmony)
+#endif
+        {
+            harmony.Patch(
+                original: AccessTools.Method(typeof(NPC), nameof(NPC.parseMasterSchedule)),
+#if HARMONY_2
+                finalizer: new HarmonyMethod(this.GetType(), nameof(ScheduleErrorPatch.Finalize_NPC_parseMasterSchedule))
+#else
+                prefix: new HarmonyMethod(this.GetType(), nameof(ScheduleErrorPatch.Before_NPC_parseMasterSchedule))
+#endif
+            );
+        }
+
+
+        /*********
+        ** Private methods
+        *********/
+#if HARMONY_2
+        /// <summary>The method to call instead of <see cref="NPC.parseMasterSchedule"/>.</summary>
+        /// <param name="rawData">The raw schedule data to parse.</param>
+        /// <param name="__instance">The instance being patched.</param>
+        /// <param name="__result">The patched method's return value.</param>
+        /// <param name="__exception">The exception thrown by the wrapped method, if any.</param>
+        /// <returns>Returns the exception to throw, if any.</returns>
+        private static Exception Finalize_NPC_parseMasterSchedule(string rawData, NPC __instance, ref Dictionary<int, SchedulePathDescription> __result, Exception __exception)
+        {
+            if (__exception != null)
+            {
+                ScheduleErrorPatch.MonitorForGame.Log($"Failed parsing schedule for NPC {__instance.Name}:\n{rawData}\n{__exception.GetLogSummary()}", LogLevel.Error);
+                __result = new Dictionary<int, SchedulePathDescription>();
+            }
+
+            return null;
+        }
+#else
+        /// <summary>The method to call instead of <see cref="NPC.parseMasterSchedule"/>.</summary>
+        /// <param name="rawData">The raw schedule data to parse.</param>
+        /// <param name="__instance">The instance being patched.</param>
+        /// <param name="__result">The patched method's return value.</param>
+        /// <param name="__originalMethod">The method being wrapped.</param>
+        /// <returns>Returns whether to execute the original method.</returns>
+        private static bool Before_NPC_parseMasterSchedule(string rawData, NPC __instance, ref Dictionary<int, SchedulePathDescription> __result, MethodInfo __originalMethod)
+        {
+            const string key = nameof(ScheduleErrorPatch.Before_NPC_parseMasterSchedule);
+            if (!PatchHelper.StartIntercept(key))
+                return true;
+
+            try
+            {
+                __result = (Dictionary<int, SchedulePathDescription>)__originalMethod.Invoke(__instance, new object[] { rawData });
+                return false;
+            }
+            catch (TargetInvocationException ex)
+            {
+                ScheduleErrorPatch.MonitorForGame.Log($"Failed parsing schedule for NPC {__instance.Name}:\n{rawData}\n{ex.InnerException ?? ex}", LogLevel.Error);
+                __result = new Dictionary<int, SchedulePathDescription>();
+                return false;
+            }
+            finally
+            {
+                PatchHelper.StopIntercept(key);
+            }
+        }
+#endif
+    }
+}