Merge branch 'stardew-valley-1.5' into develop

# Conflicts:
#	docs/release-notes.md

12 files changed, 744 insertions, 497 deletions

diff --git a/src/SMAPI/Framework/ContentManagers/GameContentManager.cs b/src/SMAPI/Framework/ContentManagers/GameContentManager.cs
index f20580e1..83a63986 100644
--- a/src/SMAPI/Framework/ContentManagers/GameContentManager.cs
+++ b/src/SMAPI/Framework/ContentManagers/GameContentManager.cs
@@ -29,8 +29,8 @@ namespace StardewModdingAPI.Framework.ContentManagers
         /// <summary>Interceptors which edit matching assets after they're loaded.</summary>
         private IList<ModLinked<IAssetEditor>> Editors => this.Coordinator.Editors;
 
-        /// <summary>A lookup which indicates whether the asset is localizable (i.e. the filename contains the locale), if previously loaded.</summary>
-        private readonly IDictionary<string, bool> IsLocalizableLookup;
+        /// <summary>Maps asset names to their localized form, like <c>LooseSprites\Billboard => LooseSprites\Billboard.fr-FR</c> (localized) or <c>Maps\AnimalShop => Maps\AnimalShop</c> (not localized).</summary>
+        private IDictionary<string, string> LocalizedAssetNames => LocalizedContentManager.localizedAssetNames;
 
         /// <summary>Whether the next load is the first for any game content manager.</summary>
         private static bool IsFirstLoad = true;
@@ -55,7 +55,6 @@ namespace StardewModdingAPI.Framework.ContentManagers
         public GameContentManager(string name, IServiceProvider serviceProvider, string rootDirectory, CultureInfo currentCulture, ContentCoordinator coordinator, IMonitor monitor, Reflector reflection, Action<BaseContentManager> onDisposing, Action onLoadingFirstAsset)
             : base(name, serviceProvider, rootDirectory, currentCulture, coordinator, monitor, reflection, onDisposing, isNamespaced: false)
         {
-            this.IsLocalizableLookup = reflection.GetField<IDictionary<string, bool>>(this, "_localizedAsset").GetValue();
             this.OnLoadingFirstAsset = onLoadingFirstAsset;
         }
 
@@ -124,7 +123,7 @@ namespace StardewModdingAPI.Framework.ContentManagers
 
             // find assets for which a translatable version was loaded
             HashSet<string> removeAssetNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
-            foreach (string key in this.IsLocalizableLookup.Where(p => p.Value).Select(p => p.Key))
+            foreach (string key in this.LocalizedAssetNames.Where(p => p.Key != p.Value).Select(p => p.Key))
                 removeAssetNames.Add(this.TryParseExplicitLanguageAssetKey(key, out string assetName, out _) ? assetName : key);
 
             // invalidate translatable assets
@@ -154,21 +153,15 @@ namespace StardewModdingAPI.Framework.ContentManagers
         /// <param name="normalizedAssetName">The normalized asset name.</param>
         protected override bool IsNormalizedKeyLoaded(string normalizedAssetName)
         {
-            // default English
-            if (this.Language == LocalizedContentManager.LanguageCode.en || this.Coordinator.IsManagedAssetKey(normalizedAssetName))
-                return this.Cache.ContainsKey(normalizedAssetName);
-
-            // translated
-            string keyWithLocale = $"{normalizedAssetName}.{this.GetLocale(this.GetCurrentLanguage())}";
-            if (this.IsLocalizableLookup.TryGetValue(keyWithLocale, out bool localizable))
-            {
-                return localizable
-                    ? this.Cache.ContainsKey(keyWithLocale)
-                    : this.Cache.ContainsKey(normalizedAssetName);
-            }
-
-            // not loaded yet
-            return false;
+            string cachedKey = null;
+            bool localized =
+                this.Language != LocalizedContentManager.LanguageCode.en
+                && !this.Coordinator.IsManagedAssetKey(normalizedAssetName)
+                && this.LocalizedAssetNames.TryGetValue(normalizedAssetName, out cachedKey);
+
+            return localized
+                ? this.Cache.ContainsKey(cachedKey)
+                : this.Cache.ContainsKey(normalizedAssetName);
         }
 
         /// <summary>Add tracking data to an asset and add it to the cache.</summary>
@@ -197,22 +190,16 @@ namespace StardewModdingAPI.Framework.ContentManagers
             //      doesn't change the instance stored in the cache, e.g. using `asset.ReplaceWith`.
             if (useCache)
             {
-                string keyWithLocale = $"{assetName}.{this.GetLocale(language)}";
+                string translatedKey = $"{assetName}.{this.GetLocale(language)}";
                 base.TrackAsset(assetName, value, language, useCache: true);
-                if (this.Cache.ContainsKey(keyWithLocale))
-                    base.TrackAsset(keyWithLocale, value, language, useCache: true);
+                if (this.Cache.ContainsKey(translatedKey))
+                    base.TrackAsset(translatedKey, value, language, useCache: true);
 
                 // track whether the injected asset is translatable for is-loaded lookups
-                if (this.Cache.ContainsKey(keyWithLocale))
-                {
-                    this.IsLocalizableLookup[assetName] = true;
-                    this.IsLocalizableLookup[keyWithLocale] = true;
-                }
+                if (this.Cache.ContainsKey(translatedKey))
+                    this.LocalizedAssetNames[assetName] = translatedKey;
                 else if (this.Cache.ContainsKey(assetName))
-                {
-                    this.IsLocalizableLookup[assetName] = false;
-                    this.IsLocalizableLookup[keyWithLocale] = false;
-                }
+                    this.LocalizedAssetNames[assetName] = assetName;
                 else
                     this.Monitor.Log($"Asset '{assetName}' could not be found in the cache immediately after injection.", LogLevel.Error);
             }
@@ -226,24 +213,23 @@ namespace StardewModdingAPI.Framework.ContentManagers
         /// <remarks>Derived from <see cref="LocalizedContentManager.Load{T}(string, LocalizedContentManager.LanguageCode)"/>.</remarks>
         private T RawLoad<T>(string assetName, LanguageCode language, bool useCache)
         {
-            // try translated asset
+            // use cached key
+            if (this.LocalizedAssetNames.TryGetValue(assetName, out string cachedKey))
+                return base.RawLoad<T>(cachedKey, useCache);
+
+            // try translated key
             if (language != LocalizedContentManager.LanguageCode.en)
             {
                 string translatedKey = $"{assetName}.{this.GetLocale(language)}";
-                if (!this.IsLocalizableLookup.TryGetValue(translatedKey, out bool isTranslatable) || isTranslatable)
+                try
                 {
-                    try
-                    {
-                        T obj = base.RawLoad<T>(translatedKey, useCache);
-                        this.IsLocalizableLookup[assetName] = true;
-                        this.IsLocalizableLookup[translatedKey] = true;
-                        return obj;
-                    }
-                    catch (ContentLoadException)
-                    {
-                        this.IsLocalizableLookup[assetName] = false;
-                        this.IsLocalizableLookup[translatedKey] = false;
-                    }
+                    T obj = base.RawLoad<T>(translatedKey, useCache);
+                    this.LocalizedAssetNames[assetName] = translatedKey;
+                    return obj;
+                }
+                catch (ContentLoadException)
+                {
+                    this.LocalizedAssetNames[assetName] = assetName;
                 }
             }
 
diff --git a/src/SMAPI/Framework/ContentManagers/ModContentManager.cs b/src/SMAPI/Framework/ContentManagers/ModContentManager.cs
index 12d672cf..127705ea 100644
--- a/src/SMAPI/Framework/ContentManagers/ModContentManager.cs
+++ b/src/SMAPI/Framework/ContentManagers/ModContentManager.cs
@@ -12,7 +12,6 @@ using StardewModdingAPI.Toolkit.Utilities;
 using StardewValley;
 using xTile;
 using xTile.Format;
-using xTile.ObjectModel;
 using xTile.Tiles;
 
 namespace StardewModdingAPI.Framework.ContentManagers
@@ -127,8 +126,8 @@ namespace StardewModdingAPI.Framework.ContentManagers
                             asset = this.RawLoad<T>(assetName, useCache: false);
                             if (asset is Map map)
                             {
-                                this.NormalizeTilesheetPaths(map);
-                                this.FixCustomTilesheetPaths(map, relativeMapPath: assetName);
+                                map.assetPath = assetName;
+                                this.FixTilesheetPaths(map, relativeMapPath: assetName);
                             }
                         }
                         break;
@@ -168,8 +167,8 @@ namespace StardewModdingAPI.Framework.ContentManagers
                             // fetch & cache
                             FormatManager formatManager = FormatManager.Instance;
                             Map map = formatManager.LoadMap(file.FullName);
-                            this.NormalizeTilesheetPaths(map);
-                            this.FixCustomTilesheetPaths(map, relativeMapPath: assetName);
+                            map.assetPath = assetName;
+                            this.FixTilesheetPaths(map, relativeMapPath: assetName);
                             asset = (T)(object)map;
                         }
                         break;
@@ -257,44 +256,21 @@ namespace StardewModdingAPI.Framework.ContentManagers
             return texture;
         }
 
-        /// <summary>Normalize map tilesheet paths for the current platform.</summary>
-        /// <param name="map">The map whose tilesheets to fix.</param>
-        private void NormalizeTilesheetPaths(Map map)
-        {
-            foreach (TileSheet tilesheet in map.TileSheets)
-                tilesheet.ImageSource = this.NormalizePathSeparators(tilesheet.ImageSource);
-        }
-
         /// <summary>Fix custom map tilesheet paths so they can be found by the content manager.</summary>
         /// <param name="map">The map whose tilesheets to fix.</param>
         /// <param name="relativeMapPath">The relative map path within the mod folder.</param>
         /// <exception cref="ContentLoadException">A map tilesheet couldn't be resolved.</exception>
-        /// <remarks>
-        /// The game's logic for tilesheets in <see cref="Game1.setGraphicsForSeason"/> is a bit specialized. It boils
-        /// down to this:
-        ///  * If the location is indoors or the desert, or the image source contains 'path' or 'object', it's loaded
-        ///    as-is relative to the <c>Content</c> folder.
-        ///  * Else it's loaded from <c>Content\Maps</c> with a seasonal prefix.
-        ///
-        /// That logic doesn't work well in our case, mainly because we have no location metadata at this point.
-        /// Instead we use a more heuristic approach: check relative to the map file first, then relative to
-        /// <c>Content\Maps</c>, then <c>Content</c>. If the image source filename contains a seasonal prefix, try for a
-        /// seasonal variation and then an exact match.
-        ///
-        /// While that doesn't exactly match the game logic, it's close enough that it's unlikely to make a difference.
-        /// </remarks>
-        private void FixCustomTilesheetPaths(Map map, string relativeMapPath)
+        private void FixTilesheetPaths(Map map, string relativeMapPath)
         {
             // get map info
-            if (!map.TileSheets.Any())
-                return;
             relativeMapPath = this.AssertAndNormalizeAssetName(relativeMapPath); // Mono's Path.GetDirectoryName doesn't handle Windows dir separators
             string relativeMapFolder = Path.GetDirectoryName(relativeMapPath) ?? ""; // folder path containing the map, relative to the mod folder
-            bool isOutdoors = map.Properties.TryGetValue("Outdoors", out PropertyValue outdoorsProperty) && outdoorsProperty != null;
 
             // fix tilesheets
             foreach (TileSheet tilesheet in map.TileSheets)
             {
+                tilesheet.ImageSource = this.NormalizePathSeparators(tilesheet.ImageSource);
+
                 string imageSource = tilesheet.ImageSource;
                 string errorPrefix = $"{this.ModName} loaded map '{relativeMapPath}' with invalid tilesheet path '{imageSource}'.";
 
@@ -305,7 +281,7 @@ namespace StardewModdingAPI.Framework.ContentManagers
                 // load best match
                 try
                 {
-                    if (!this.TryGetTilesheetAssetName(relativeMapFolder, imageSource, isOutdoors, out string assetName, out string error))
+                    if (!this.TryGetTilesheetAssetName(relativeMapFolder, imageSource, out string assetName, out string error))
                         throw new SContentLoadException($"{errorPrefix} {error}");
 
                     tilesheet.ImageSource = assetName;
@@ -319,37 +295,23 @@ namespace StardewModdingAPI.Framework.ContentManagers
 
         /// <summary>Get the actual asset name for a tilesheet.</summary>
         /// <param name="modRelativeMapFolder">The folder path containing the map, relative to the mod folder.</param>
-        /// <param name="originalPath">The tilesheet path to load.</param>
-        /// <param name="willSeasonalize">Whether the game will apply seasonal logic to the tilesheet.</param>
+        /// <param name="relativePath">The tilesheet path to load.</param>
         /// <param name="assetName">The found asset name.</param>
         /// <param name="error">A message indicating why the file couldn't be loaded.</param>
         /// <returns>Returns whether the asset name was found.</returns>
-        /// <remarks>See remarks on <see cref="FixCustomTilesheetPaths"/>.</remarks>
-        private bool TryGetTilesheetAssetName(string modRelativeMapFolder, string originalPath, bool willSeasonalize, out string assetName, out string error)
+        /// <remarks>See remarks on <see cref="FixTilesheetPaths"/>.</remarks>
+        private bool TryGetTilesheetAssetName(string modRelativeMapFolder, string relativePath, out string assetName, out string error)
         {
             assetName = null;
             error = null;
 
             // nothing to do
-            if (string.IsNullOrWhiteSpace(originalPath))
+            if (string.IsNullOrWhiteSpace(relativePath))
             {
-                assetName = originalPath;
+                assetName = relativePath;
                 return true;
             }
 
-            // parse path
-            string filename = Path.GetFileName(originalPath);
-            bool isSeasonal = filename.StartsWith("spring_", StringComparison.CurrentCultureIgnoreCase)
-                || filename.StartsWith("summer_", StringComparison.CurrentCultureIgnoreCase)
-                || filename.StartsWith("fall_", StringComparison.CurrentCultureIgnoreCase)
-                || filename.StartsWith("winter_", StringComparison.CurrentCultureIgnoreCase);
-            string relativePath = originalPath;
-            if (willSeasonalize && isSeasonal)
-            {
-                string dirPath = Path.GetDirectoryName(originalPath);
-                relativePath = Path.Combine(dirPath, $"{Game1.currentSeason}_{filename.Substring(filename.IndexOf("_", StringComparison.CurrentCultureIgnoreCase) + 1)}");
-            }
-
             // get relative to map file
             {
                 string localKey = Path.Combine(modRelativeMapFolder, relativePath);
@@ -361,38 +323,24 @@ namespace StardewModdingAPI.Framework.ContentManagers
             }
 
             // get from game assets
-            // Map tilesheet keys shouldn't include the "Maps/" prefix (the game will add it automatically) or ".png" extension.
+            string contentKey = this.GetContentKeyForTilesheetImageSource(relativePath);
+            try
             {
-                string contentKey = relativePath;
-                foreach (char separator in PathUtilities.PossiblePathSeparators)
-                {
-                    if (contentKey.StartsWith($"Maps{separator}"))
-                    {
-                        contentKey = contentKey.Substring(5);
-                        break;
-                    }
-                }
-                if (contentKey.EndsWith(".png", StringComparison.OrdinalIgnoreCase))
-                    contentKey = contentKey.Substring(0, contentKey.Length - 4);
-
-                try
-                {
-                    this.GameContentManager.Load<Texture2D>(Path.Combine("Maps", contentKey), this.Language, useCache: true); // no need to bypass cache here, since we're not storing the asset
-                    assetName = contentKey;
-                    return true;
-                }
-                catch
-                {
-                    // ignore file-not-found errors
-                    // TODO: while it's useful to suppress an asset-not-found error here to avoid
-                    // confusion, this is a pretty naive approach. Even if the file doesn't exist,
-                    // the file may have been loaded through an IAssetLoader which failed. So even
-                    // if the content file doesn't exist, that doesn't mean the error here is a
-                    // content-not-found error. Unfortunately XNA doesn't provide a good way to
-                    // detect the error type.
-                    if (this.GetContentFolderFileExists(contentKey))
-                        throw;
-                }
+                this.GameContentManager.Load<Texture2D>(contentKey, this.Language, useCache: true); // no need to bypass cache here, since we're not storing the asset
+                assetName = contentKey;
+                return true;
+            }
+            catch
+            {
+                // ignore file-not-found errors
+                // TODO: while it's useful to suppress an asset-not-found error here to avoid
+                // confusion, this is a pretty naive approach. Even if the file doesn't exist,
+                // the file may have been loaded through an IAssetLoader which failed. So even
+                // if the content file doesn't exist, that doesn't mean the error here is a
+                // content-not-found error. Unfortunately XNA doesn't provide a good way to
+                // detect the error type.
+                if (this.GetContentFolderFileExists(contentKey))
+                    throw;
             }
 
             // not found
@@ -412,5 +360,23 @@ namespace StardewModdingAPI.Framework.ContentManagers
             // get file
             return new FileInfo(path).Exists;
         }
+
+        /// <summary>Get the asset key for a tilesheet in the game's <c>Maps</c> content folder.</summary>
+        /// <param name="relativePath">The tilesheet image source.</param>
+        private string GetContentKeyForTilesheetImageSource(string relativePath)
+        {
+            string key = relativePath;
+            string topFolder = PathUtilities.GetSegments(key, limit: 2)[0];
+
+            // convert image source relative to map file into asset key
+            if (!topFolder.Equals("Maps", StringComparison.OrdinalIgnoreCase))
+                key = Path.Combine("Maps", key);
+
+            // remove file extension from unpacked file
+            if (key.EndsWith(".png", StringComparison.OrdinalIgnoreCase))
+                key = key.Substring(0, key.Length - 4);
+
+            return key;
+        }
     }
 }
diff --git a/src/SMAPI/Framework/Input/SInputState.cs b/src/SMAPI/Framework/Input/SInputState.cs
index f618608a..23670202 100644
--- a/src/SMAPI/Framework/Input/SInputState.cs
+++ b/src/SMAPI/Framework/Input/SInputState.cs
@@ -65,13 +65,16 @@ namespace StardewModdingAPI.Framework.Input
             // update SMAPI extended data
             try
             {
-                float zoomMultiplier = (1f / Game1.options.zoomLevel);
+                float scale = Game1.options.uiScale;
 
                 // get real values
                 var controller = new GamePadStateBuilder(base.GetGamePadState());
                 var keyboard = new KeyboardStateBuilder(base.GetKeyboardState());
                 var mouse = new MouseStateBuilder(base.GetMouseState());
-                Vector2 cursorAbsolutePos = new Vector2((mouse.X * zoomMultiplier) + Game1.viewport.X, (mouse.Y * zoomMultiplier) + Game1.viewport.Y);
+                Vector2 cursorAbsolutePos = new Vector2(
+                    x: (mouse.X / scale) + Game1.uiViewport.X,
+                    y: (mouse.Y / scale) + Game1.uiViewport.Y
+                );
                 Vector2? playerTilePos = Context.IsPlayerFree ? Game1.player.getTileLocation() : (Vector2?)null;
                 HashSet<SButton> reallyDown = new HashSet<SButton>(this.GetPressedButtons(keyboard, mouse, controller));
 
@@ -106,7 +109,7 @@ namespace StardewModdingAPI.Framework.Input
                 if (cursorAbsolutePos != this.CursorPositionImpl?.AbsolutePixels || playerTilePos != this.LastPlayerTile)
                 {
                     this.LastPlayerTile = playerTilePos;
-                    this.CursorPositionImpl = this.GetCursorPosition(this.MouseState, cursorAbsolutePos, zoomMultiplier);
+                    this.CursorPositionImpl = this.GetCursorPosition(this.MouseState, cursorAbsolutePos, scale);
                 }
             }
             catch (InvalidOperationException)
@@ -199,11 +202,11 @@ namespace StardewModdingAPI.Framework.Input
         /// <summary>Get the current cursor position.</summary>
         /// <param name="mouseState">The current mouse state.</param>
         /// <param name="absolutePixels">The absolute pixel position relative to the map, adjusted for pixel zoom.</param>
-        /// <param name="zoomMultiplier">The multiplier applied to pixel coordinates to adjust them for pixel zoom.</param>
-        private CursorPosition GetCursorPosition(MouseState mouseState, Vector2 absolutePixels, float zoomMultiplier)
+        /// <param name="scale">The UI scale applied to pixel coordinates.</param>
+        private CursorPosition GetCursorPosition(MouseState mouseState, Vector2 absolutePixels, float scale)
         {
-            Vector2 screenPixels = new Vector2(mouseState.X * zoomMultiplier, mouseState.Y * zoomMultiplier);
-            Vector2 tile = new Vector2((int)((Game1.viewport.X + screenPixels.X) / Game1.tileSize), (int)((Game1.viewport.Y + screenPixels.Y) / Game1.tileSize));
+            Vector2 screenPixels = new Vector2(mouseState.X / scale, mouseState.Y / scale);
+            Vector2 tile = new Vector2((int)((Game1.uiViewport.X + screenPixels.X) / Game1.tileSize), (int)((Game1.uiViewport.Y + screenPixels.Y) / Game1.tileSize));
             Vector2 grabTile = (Game1.mouseCursorTransparency > 0 && Utility.tileWithinRadiusOfPlayer((int)tile.X, (int)tile.Y, 1, Game1.player)) // derived from Game1.pressActionButton
                 ? tile
                 : Game1.player.GetGrabTile();
diff --git a/src/SMAPI/Framework/InternalExtensions.cs b/src/SMAPI/Framework/InternalExtensions.cs
index b6704f26..ba1879da 100644
--- a/src/SMAPI/Framework/InternalExtensions.cs
+++ b/src/SMAPI/Framework/InternalExtensions.cs
@@ -1,11 +1,13 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Reflection;
 using System.Threading;
 using Microsoft.Xna.Framework.Graphics;
 using StardewModdingAPI.Framework.Events;
 using StardewModdingAPI.Framework.Reflection;
 using StardewValley;
+using StardewValley.Menus;
 
 namespace StardewModdingAPI.Framework
 {
@@ -154,6 +156,22 @@ namespace StardewModdingAPI.Framework
         }
 
         /****
+        ** IActiveClickableMenu
+        ****/
+        /// <summary>Get a string representation of the menu chain to the given menu (including the specified menu), in parent to child order.</summary>
+        /// <param name="menu">The menu whose chain to get.</param>
+        public static string GetMenuChainLabel(this IClickableMenu menu)
+        {
+            static IEnumerable<IClickableMenu> GetAncestors(IClickableMenu menu)
+            {
+                for (; menu != null; menu = menu.GetParentMenu())
+                    yield return menu;
+            }
+
+            return string.Join(" > ", GetAncestors(menu).Reverse().Select(p => p.GetType().FullName));
+        }
+
+        /****
         ** Sprite batch
         ****/
         /// <summary>Get whether the sprite batch is between a begin and end pair.</summary>
diff --git a/src/SMAPI/Framework/Logging/LogManager.cs b/src/SMAPI/Framework/Logging/LogManager.cs
index 1e484709..ee013a85 100644
--- a/src/SMAPI/Framework/Logging/LogManager.cs
+++ b/src/SMAPI/Framework/Logging/LogManager.cs
@@ -32,10 +32,10 @@ namespace StardewModdingAPI.Framework.Logging
         private readonly Regex[] SuppressConsolePatterns =
         {
             new Regex(@"^TextBox\.Selected is now '(?:True|False)'\.$", RegexOptions.Compiled | RegexOptions.CultureInvariant),
-            new Regex(@"^(?:FRUIT )?TREE: IsClient:(?:True|False) randomOutput: \d+$", RegexOptions.Compiled | RegexOptions.CultureInvariant),
             new Regex(@"^loadPreferences\(\); begin", RegexOptions.Compiled | RegexOptions.CultureInvariant),
             new Regex(@"^savePreferences\(\); async=", RegexOptions.Compiled | RegexOptions.CultureInvariant),
-            new Regex(@"^DebugOutput:\s+(?:added CLOUD|added cricket|dismount tile|Ping|playerPos)", RegexOptions.Compiled | RegexOptions.CultureInvariant)
+            new Regex(@"^DebugOutput:\s+(?:added cricket|dismount tile|Ping|playerPos)", RegexOptions.Compiled | RegexOptions.CultureInvariant),
+            new Regex(@"^Ignoring keys: ", RegexOptions.Compiled | RegexOptions.CultureInvariant)
         };
 
         /// <summary>Regex patterns which match console messages to show a more friendly error for.</summary>
@@ -84,10 +84,11 @@ namespace StardewModdingAPI.Framework.Logging
         /// <param name="writeToConsole">Whether to output log messages to the console.</param>
         /// <param name="isVerbose">Whether verbose logging is enabled. This enables more detailed diagnostic messages than are normally needed.</param>
         /// <param name="isDeveloperMode">Whether to enable full console output for developers.</param>
-        public LogManager(string logPath, ColorSchemeConfig colorConfig, bool writeToConsole, bool isVerbose, bool isDeveloperMode)
+        /// <param name="getScreenIdForLog">Get the screen ID that should be logged to distinguish between players in split-screen mode, if any.</param>
+        public LogManager(string logPath, ColorSchemeConfig colorConfig, bool writeToConsole, bool isVerbose, bool isDeveloperMode, Func<int?> getScreenIdForLog)
         {
             // init construction logic
-            this.GetMonitorImpl = name => new Monitor(name, this.IgnoreChar, this.LogFile, colorConfig, isVerbose)
+            this.GetMonitorImpl = name => new Monitor(name, this.IgnoreChar, this.LogFile, colorConfig, isVerbose, getScreenIdForLog)
             {
                 WriteToConsole = writeToConsole,
                 ShowTraceInConsole = isDeveloperMode,
diff --git a/src/SMAPI/Framework/ModHelpers/DataHelper.cs b/src/SMAPI/Framework/ModHelpers/DataHelper.cs
index 41612387..0fe3209f 100644
--- a/src/SMAPI/Framework/ModHelpers/DataHelper.cs
+++ b/src/SMAPI/Framework/ModHelpers/DataHelper.cs
@@ -69,8 +69,8 @@ namespace StardewModdingAPI.Framework.ModHelpers
         {
             if (Context.LoadStage == LoadStage.None)
                 throw new InvalidOperationException($"Can't use {nameof(IMod.Helper)}.{nameof(IModHelper.Data)}.{nameof(this.ReadSaveData)} when a save file isn't loaded.");
-            if (!Game1.IsMasterGame)
-                throw new InvalidOperationException($"Can't use {nameof(IMod.Helper)}.{nameof(IModHelper.Data)}.{nameof(this.ReadSaveData)} because this isn't the main player. (Save files are stored on the main player's computer.)");
+            if (!Context.IsOnHostComputer)
+                throw new InvalidOperationException($"Can't use {nameof(IMod.Helper)}.{nameof(IModHelper.Data)}.{nameof(this.ReadSaveData)} when connected to a remote host. (Save files are stored on the main player's computer.)");
 
 
             string internalKey = this.GetSaveFileKey(key);
@@ -87,8 +87,8 @@ namespace StardewModdingAPI.Framework.ModHelpers
         {
             if (Context.LoadStage == LoadStage.None)
                 throw new InvalidOperationException($"Can't use {nameof(IMod.Helper)}.{nameof(IModHelper.Data)}.{nameof(this.WriteSaveData)} when a save file isn't loaded.");
-            if (!Game1.IsMasterGame)
-                throw new InvalidOperationException($"Can't use {nameof(IMod.Helper)}.{nameof(IModHelper.Data)}.{nameof(this.WriteSaveData)} because this isn't the main player. (Save files are stored on the main player's computer.)");
+            if (!Context.IsOnHostComputer)
+                throw new InvalidOperationException($"Can't use {nameof(IMod.Helper)}.{nameof(IModHelper.Data)}.{nameof(this.WriteSaveData)} when connected to a remote host. (Save files are stored on the main player's computer.)");
 
             string internalKey = this.GetSaveFileKey(key);
             string data = model != null
diff --git a/src/SMAPI/Framework/ModHelpers/InputHelper.cs b/src/SMAPI/Framework/ModHelpers/InputHelper.cs
index 09ce3c65..e1317544 100644
--- a/src/SMAPI/Framework/ModHelpers/InputHelper.cs
+++ b/src/SMAPI/Framework/ModHelpers/InputHelper.cs
@@ -1,3 +1,4 @@
+using System;
 using StardewModdingAPI.Framework.Input;
 
 namespace StardewModdingAPI.Framework.ModHelpers
@@ -8,8 +9,8 @@ namespace StardewModdingAPI.Framework.ModHelpers
         /*********
         ** Accessors
         *********/
-        /// <summary>Manages the game's input state.</summary>
-        private readonly SInputState InputState;
+        /// <summary>Manages the game's input state for the current player instance. That may not be the main player in split-screen mode.</summary>
+        private readonly Func<SInputState> CurrentInputState;
 
 
         /*********
@@ -17,41 +18,41 @@ namespace StardewModdingAPI.Framework.ModHelpers
         *********/
         /// <summary>Construct an instance.</summary>
         /// <param name="modID">The unique ID of the relevant mod.</param>
-        /// <param name="inputState">Manages the game's input state.</param>
-        public InputHelper(string modID, SInputState inputState)
+        /// <param name="currentInputState">Manages the game's input state for the current player instance. That may not be the main player in split-screen mode.</param>
+        public InputHelper(string modID, Func<SInputState> currentInputState)
             : base(modID)
         {
-            this.InputState = inputState;
+            this.CurrentInputState = currentInputState;
         }
 
         /// <inheritdoc />
         public ICursorPosition GetCursorPosition()
         {
-            return this.InputState.CursorPosition;
+            return this.CurrentInputState().CursorPosition;
         }
 
         /// <inheritdoc />
         public bool IsDown(SButton button)
         {
-            return this.InputState.IsDown(button);
+            return this.CurrentInputState().IsDown(button);
         }
 
         /// <inheritdoc />
         public bool IsSuppressed(SButton button)
         {
-            return this.InputState.IsSuppressed(button);
+            return this.CurrentInputState().IsSuppressed(button);
         }
 
         /// <inheritdoc />
         public void Suppress(SButton button)
         {
-            this.InputState.OverrideButton(button, setDown: false);
+            this.CurrentInputState().OverrideButton(button, setDown: false);
         }
 
         /// <inheritdoc />
         public SButtonState GetState(SButton button)
         {
-            return this.InputState.GetState(button);
+            return this.CurrentInputState().GetState(button);
         }
     }
 }
diff --git a/src/SMAPI/Framework/ModHelpers/ModHelper.cs b/src/SMAPI/Framework/ModHelpers/ModHelper.cs
index d9fc8621..058bff83 100644
--- a/src/SMAPI/Framework/ModHelpers/ModHelper.cs
+++ b/src/SMAPI/Framework/ModHelpers/ModHelper.cs
@@ -51,7 +51,7 @@ namespace StardewModdingAPI.Framework.ModHelpers
         /// <summary>Construct an instance.</summary>
         /// <param name="modID">The mod's unique ID.</param>
         /// <param name="modDirectory">The full path to the mod's folder.</param>
-        /// <param name="inputState">Manages the game's input state.</param>
+        /// <param name="currentInputState">Manages the game's input state for the current player instance. That may not be the main player in split-screen mode.</param>
         /// <param name="events">Manages access to events raised by SMAPI.</param>
         /// <param name="contentHelper">An API for loading content assets.</param>
         /// <param name="contentPackHelper">An API for managing content packs.</param>
@@ -63,7 +63,7 @@ namespace StardewModdingAPI.Framework.ModHelpers
         /// <param name="translationHelper">An API for reading translations stored in the mod's <c>i18n</c> folder.</param>
         /// <exception cref="ArgumentNullException">An argument is null or empty.</exception>
         /// <exception cref="InvalidOperationException">The <paramref name="modDirectory"/> path does not exist on disk.</exception>
-        public ModHelper(string modID, string modDirectory, SInputState inputState, IModEvents events, IContentHelper contentHelper, IContentPackHelper contentPackHelper, ICommandHelper commandHelper, IDataHelper dataHelper, IModRegistry modRegistry, IReflectionHelper reflectionHelper, IMultiplayerHelper multiplayer, ITranslationHelper translationHelper)
+        public ModHelper(string modID, string modDirectory, Func<SInputState> currentInputState, IModEvents events, IContentHelper contentHelper, IContentPackHelper contentPackHelper, ICommandHelper commandHelper, IDataHelper dataHelper, IModRegistry modRegistry, IReflectionHelper reflectionHelper, IMultiplayerHelper multiplayer, ITranslationHelper translationHelper)
             : base(modID)
         {
             // validate directory
@@ -77,7 +77,7 @@ namespace StardewModdingAPI.Framework.ModHelpers
             this.Content = contentHelper ?? throw new ArgumentNullException(nameof(contentHelper));
             this.ContentPacks = contentPackHelper ?? throw new ArgumentNullException(nameof(contentPackHelper));
             this.Data = dataHelper ?? throw new ArgumentNullException(nameof(dataHelper));
-            this.Input = new InputHelper(modID, inputState);
+            this.Input = new InputHelper(modID, currentInputState);
             this.ModRegistry = modRegistry ?? throw new ArgumentNullException(nameof(modRegistry));
             this.ConsoleCommands = commandHelper ?? throw new ArgumentNullException(nameof(commandHelper));
             this.Reflection = reflectionHelper ?? throw new ArgumentNullException(nameof(reflectionHelper));
diff --git a/src/SMAPI/Framework/Monitor.cs b/src/SMAPI/Framework/Monitor.cs
index 533420a5..04e67d68 100644
--- a/src/SMAPI/Framework/Monitor.cs
+++ b/src/SMAPI/Framework/Monitor.cs
@@ -30,6 +30,9 @@ namespace StardewModdingAPI.Framework
         /// <summary>A cache of messages that should only be logged once.</summary>
         private readonly HashSet<string> LogOnceCache = new HashSet<string>();
 
+        /// <summary>Get the screen ID that should be logged to distinguish between players in split-screen mode, if any.</summary>
+        private readonly Func<int?> GetScreenIdForLog;
+
 
         /*********
         ** Accessors
@@ -56,7 +59,8 @@ namespace StardewModdingAPI.Framework
         /// <param name="logFile">The log file to which to write messages.</param>
         /// <param name="colorConfig">The colors to use for text written to the SMAPI console.</param>
         /// <param name="isVerbose">Whether verbose logging is enabled. This enables more detailed diagnostic messages than are normally needed.</param>
-        public Monitor(string source, char ignoreChar, LogFileManager logFile, ColorSchemeConfig colorConfig, bool isVerbose)
+        /// <param name="getScreenIdForLog">Get the screen ID that should be logged to distinguish between players in split-screen mode, if any.</param>
+        public Monitor(string source, char ignoreChar, LogFileManager logFile, ColorSchemeConfig colorConfig, bool isVerbose, Func<int?> getScreenIdForLog)