From d1a829497292ea4c72da5f9bbfb3b50404e06022 Mon Sep 17 00:00:00 2001
From: Jesse Plamondon-Willard <github@jplamondonw.com>
Date: Thu, 28 Dec 2017 00:16:54 -0500
Subject: fix issue where assemblies could be incorrectly reloaded

---
 docs/release-notes.md | 4 ++++
 1 file changed, 4 insertions(+)

(limited to 'docs')

diff --git a/docs/release-notes.md b/docs/release-notes.md
index 165e7d4e..aaa6d3cc 100644
--- a/docs/release-notes.md
+++ b/docs/release-notes.md
@@ -1,4 +1,8 @@
 # Release notes
+## 2.4
+* For players:
+  * Fixed rare issues caused by assembly references being incorrectly loaded twice.
+
 ## 2.3
 * For players:
   * Added a user-friendly [download page](https://smapi.io).
-- 
cgit 


From d471ac296e2e6ca737781f80794a521b74ac75fb Mon Sep 17 00:00:00 2001
From: Jesse Plamondon-Willard <github@jplamondonw.com>
Date: Tue, 2 Jan 2018 16:48:33 -0500
Subject: fix parse error for logs with zero installed mods

---
 docs/release-notes.md                          | 3 +++
 src/SMAPI.Web/Views/LogParser/Index.cshtml     | 4 ++--
 src/SMAPI.Web/wwwroot/Content/js/log-parser.js | 2 +-
 3 files changed, 6 insertions(+), 3 deletions(-)

(limited to 'docs')

diff --git a/docs/release-notes.md b/docs/release-notes.md
index aaa6d3cc..a7a3c97f 100644
--- a/docs/release-notes.md
+++ b/docs/release-notes.md
@@ -3,6 +3,9 @@
 * For players:
   * Fixed rare issues caused by assembly references being incorrectly loaded twice.
 
+* For the [log parser][]:
+  * Fixed parse error for logs with zero installed mods.
+
 ## 2.3
 * For players:
   * Added a user-friendly [download page](https://smapi.io).
diff --git a/src/SMAPI.Web/Views/LogParser/Index.cshtml b/src/SMAPI.Web/Views/LogParser/Index.cshtml
index b7724c69..1659de8f 100644
--- a/src/SMAPI.Web/Views/LogParser/Index.cshtml
+++ b/src/SMAPI.Web/Views/LogParser/Index.cshtml
@@ -3,9 +3,9 @@
 }
 @model StardewModdingAPI.Web.ViewModels.LogParserModel
 @section Head {
-    <link rel="stylesheet" href="~/Content/css/log-parser.css?r=20171202" />
+    <link rel="stylesheet" href="~/Content/css/log-parser.css?r=20180101" />
     <script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.2.1/jquery.min.js" crossorigin="anonymous"></script>
-    <script src="~/Content/js/log-parser.js?r=20171202"></script>
+    <script src="~/Content/js/log-parser.js?r=20180101"></script>
     <style type="text/css" id="modflags"></style>
     <script>
         $(function() {
diff --git a/src/SMAPI.Web/wwwroot/Content/js/log-parser.js b/src/SMAPI.Web/wwwroot/Content/js/log-parser.js
index 6cce1ce9..914863f6 100644
--- a/src/SMAPI.Web/wwwroot/Content/js/log-parser.js
+++ b/src/SMAPI.Web/wwwroot/Content/js/log-parser.js
@@ -175,7 +175,7 @@ smapi.logParser = function(sectionUrl, pasteID) {
 
         }
         var dataInfo = regexInfo.exec(data) || regexInfo.exec(data) || regexInfo.exec(data),
-            dataMods = regexMods.exec(data) || regexMods.exec(data) || regexMods.exec(data),
+            dataMods = regexMods.exec(data) || regexMods.exec(data) || regexMods.exec(data) || [""],
             dataDate = regexDate.exec(data) || regexDate.exec(data) || regexDate.exec(data),
             dataPath = regexPath.exec(data) || regexPath.exec(data) || regexPath.exec(data),
             match;
-- 
cgit 


From dc2ceb39f31c35752c943b5052d5abaa7b6494fa Mon Sep 17 00:00:00 2001
From: Jesse Plamondon-Willard <github@jplamondonw.com>
Date: Fri, 12 Jan 2018 01:11:16 -0500
Subject: fix curly quotes in config.json automatically if possible (#412)

---
 docs/release-notes.md                           |  1 +
 src/SMAPI/Framework/Serialisation/JsonHelper.cs | 44 ++++++++++++++++++++-----
 2 files changed, 36 insertions(+), 9 deletions(-)

(limited to 'docs')

diff --git a/docs/release-notes.md b/docs/release-notes.md
index a7a3c97f..87ef671e 100644
--- a/docs/release-notes.md
+++ b/docs/release-notes.md
@@ -1,6 +1,7 @@
 # Release notes
 ## 2.4
 * For players:
+  * SMAPI now fixes curly quotes in `config.json` if possible.
   * Fixed rare issues caused by assembly references being incorrectly loaded twice.
 
 * For the [log parser][]:
diff --git a/src/SMAPI/Framework/Serialisation/JsonHelper.cs b/src/SMAPI/Framework/Serialisation/JsonHelper.cs
index d923ec0c..7c4e3ee3 100644
--- a/src/SMAPI/Framework/Serialisation/JsonHelper.cs
+++ b/src/SMAPI/Framework/Serialisation/JsonHelper.cs
@@ -55,18 +55,15 @@ namespace StardewModdingAPI.Framework.Serialisation
             // deserialise model
             try
             {
-                return JsonConvert.DeserializeObject<TModel>(json, this.JsonSettings);
+                return this.Deserialise<TModel>(json);
             }
             catch (JsonReaderException ex)
             {
-                string message = $"The file at {fullPath} doesn't seem to be valid JSON.";
-
-                string text = File.ReadAllText(fullPath);
-                if (text.Contains("“") || text.Contains("”"))
-                    message += " Found curly quotes in the text; note that only straight quotes are allowed in JSON.";
-
-                message += $"\nTechnical details: {ex.Message}";
-                throw new JsonReaderException(message);
+                string error = $"The file at {fullPath} doesn't seem to be valid JSON.";
+                if (json.Contains("“") || json.Contains("”"))
+                    error += " Found curly quotes in the text; note that only straight quotes are allowed in JSON.";
+                error += $"\nTechnical details: {ex.Message}";
+                throw new JsonReaderException(error);
             }
         }
 
@@ -93,5 +90,34 @@ namespace StardewModdingAPI.Framework.Serialisation
             string json = JsonConvert.SerializeObject(model, this.JsonSettings);
             File.WriteAllText(fullPath, json);
         }
+
+
+        /*********
+        ** Private methods
+        *********/
+        /// <summary>Deserialize JSON text if possible.</summary>
+        /// <typeparam name="TModel">The model type.</typeparam>
+        /// <param name="json">The raw JSON text.</param>
+        private TModel Deserialise<TModel>(string json)
+        {
+            try
+            {
+                return JsonConvert.DeserializeObject<TModel>(json, this.JsonSettings);
+            }
+            catch (JsonReaderException)
+            {
+                // try replacing curly quotes
+                if (json.Contains("“") || json.Contains("”"))
+                {
+                    try
+                    {
+                        return JsonConvert.DeserializeObject<TModel>(json.Replace('“', '"').Replace('”', '"'), this.JsonSettings);
+                    }
+                    catch { /* rethrow original error */ }
+                }
+
+                throw;
+            }
+        }
     }
 }
-- 
cgit 


From 0ad9fbddddbf9edfd847c507d70e10d2f8ce559b Mon Sep 17 00:00:00 2001
From: Jesse Plamondon-Willard <github@jplamondonw.com>
Date: Fri, 12 Jan 2018 01:24:49 -0500
Subject: fix semantic versions always ignoring `-0` tag (#421)

---
 docs/release-notes.md                              |  1 +
 src/SMAPI.Common/SemanticVersionImpl.cs            |  4 +---
 src/SMAPI.Tests/Utilities/SemanticVersionTests.cs  | 17 ++++++++++++++
 src/SMAPI/Framework/LegacyManifestVersion.cs       | 26 ++++++++++++++++++++++
 .../Framework/Serialisation/SFieldConverter.cs     |  2 +-
 src/SMAPI/StardewModdingAPI.csproj                 |  1 +
 6 files changed, 47 insertions(+), 4 deletions(-)
 create mode 100644 src/SMAPI/Framework/LegacyManifestVersion.cs

(limited to 'docs')

diff --git a/docs/release-notes.md b/docs/release-notes.md
index 87ef671e..4b6a7ba5 100644
--- a/docs/release-notes.md
+++ b/docs/release-notes.md
@@ -2,6 +2,7 @@
 ## 2.4
 * For players:
   * SMAPI now fixes curly quotes in `config.json` if possible.
+  * Fixed semantic versions always ignoring `-0` tag.
   * Fixed rare issues caused by assembly references being incorrectly loaded twice.
 
 * For the [log parser][]:
diff --git a/src/SMAPI.Common/SemanticVersionImpl.cs b/src/SMAPI.Common/SemanticVersionImpl.cs
index 53cf5a21..1c713b47 100644
--- a/src/SMAPI.Common/SemanticVersionImpl.cs
+++ b/src/SMAPI.Common/SemanticVersionImpl.cs
@@ -190,9 +190,7 @@ namespace StardewModdingAPI.Common
         private string GetNormalisedTag(string tag)
         {
             tag = tag?.Trim();
-            if (string.IsNullOrWhiteSpace(tag) || tag == "0") // '0' from incorrect examples in old SMAPI documentation
-                return null;
-            return tag;
+            return !string.IsNullOrWhiteSpace(tag) ? tag : null;
         }
     }
 }
diff --git a/src/SMAPI.Tests/Utilities/SemanticVersionTests.cs b/src/SMAPI.Tests/Utilities/SemanticVersionTests.cs
index d3e0988e..f1a72012 100644
--- a/src/SMAPI.Tests/Utilities/SemanticVersionTests.cs
+++ b/src/SMAPI.Tests/Utilities/SemanticVersionTests.cs
@@ -33,6 +33,7 @@ namespace StardewModdingAPI.Tests.Utilities
         [TestCase(3000, 4000, 5000, null, ExpectedResult = "3000.4000.5000")]
         [TestCase(1, 2, 3, "", ExpectedResult = "1.2.3")]
         [TestCase(1, 2, 3, "    ", ExpectedResult = "1.2.3")]
+        [TestCase(1, 2, 3, "0", ExpectedResult = "1.2.3-0")]
         [TestCase(1, 2, 3, "some-tag.4", ExpectedResult = "1.2.3-some-tag.4")]
         [TestCase(1, 2, 3, "some-tag.4   ", ExpectedResult = "1.2.3-some-tag.4")]
         public string Constructor_FromParts(int major, int minor, int patch, string tag)
@@ -270,6 +271,22 @@ namespace StardewModdingAPI.Tests.Utilities
             Assert.IsTrue(version.IsOlderThan(new SemanticVersion("1.2.30")), "The game version should be considered older than the later semantic versions.");
         }
 
+        /****
+        ** LegacyManifestVersion
+        ****/
+        [Test(Description = "Assert that the LegacyManifestVersion subclass correctly parses legacy manifest versions.")]
+        [TestCase(1, 0, 0, null, ExpectedResult = "1.0")]
+        [TestCase(3000, 4000, 5000, null, ExpectedResult = "3000.4000.5000")]
+        [TestCase(1, 2, 3, "", ExpectedResult = "1.2.3")]
+        [TestCase(1, 2, 3, "    ", ExpectedResult = "1.2.3")]
+        [TestCase(1, 2, 3, "0", ExpectedResult = "1.2.3")]  // special case: drop '0' tag for legacy manifest versions
+        [TestCase(1, 2, 3, "some-tag.4", ExpectedResult = "1.2.3-some-tag.4")]
+        [TestCase(1, 2, 3, "some-tag.4   ", ExpectedResult = "1.2.3-some-tag.4")]
+        public string LegacyManifestVersion(int major, int minor, int patch, string tag)
+        {
+            return new LegacyManifestVersion(major, minor, patch, tag).ToString();
+        }
+
 
         /*********
         ** Private methods
diff --git a/src/SMAPI/Framework/LegacyManifestVersion.cs b/src/SMAPI/Framework/LegacyManifestVersion.cs
new file mode 100644
index 00000000..454b9137
--- /dev/null
+++ b/src/SMAPI/Framework/LegacyManifestVersion.cs
@@ -0,0 +1,26 @@
+using Newtonsoft.Json;
+
+namespace StardewModdingAPI.Framework
+{
+    /// <summary>An implementation of <see cref="ISemanticVersion"/> that hamdles the legacy <see cref="IManifest"/> version format.</summary>
+    internal class LegacyManifestVersion : SemanticVersion
+    {
+        /*********
+        ** Public methods
+        *********/
+        /// <summary>Construct an instance.</summary>
+        /// <param name="majorVersion">The major version incremented for major API changes.</param>
+        /// <param name="minorVersion">The minor version incremented for backwards-compatible changes.</param>
+        /// <param name="patchVersion">The patch version for backwards-compatible bug fixes.</param>
+        /// <param name="build">An optional build tag.</param>
+        [JsonConstructor]
+        public LegacyManifestVersion(int majorVersion, int minorVersion, int patchVersion, string build = null)
+            : base(
+                majorVersion,
+                minorVersion,
+                patchVersion,
+                build != "0" ? build : null // '0' from incorrect examples in old SMAPI documentation
+            )
+        { }
+    }
+}
diff --git a/src/SMAPI/Framework/Serialisation/SFieldConverter.cs b/src/SMAPI/Framework/Serialisation/SFieldConverter.cs
index 917c950d..6e068599 100644
--- a/src/SMAPI/Framework/Serialisation/SFieldConverter.cs
+++ b/src/SMAPI/Framework/Serialisation/SFieldConverter.cs
@@ -51,7 +51,7 @@ namespace StardewModdingAPI.Framework.Serialisation
                             int minor = obj.Value<int>(nameof(ISemanticVersion.MinorVersion));
                             int patch = obj.Value<int>(nameof(ISemanticVersion.PatchVersion));
                             string build = obj.Value<string>(nameof(ISemanticVersion.Build));
-                            return new SemanticVersion(major, minor, patch, build);
+                            return new LegacyManifestVersion(major, minor, patch, build);
                         }
 
                     case JTokenType.String:
diff --git a/src/SMAPI/StardewModdingAPI.csproj b/src/SMAPI/StardewModdingAPI.csproj
index f76ac439..c9c302f5 100644
--- a/src/SMAPI/StardewModdingAPI.csproj
+++ b/src/SMAPI/StardewModdingAPI.csproj
@@ -86,6 +86,7 @@
       <Link>Properties\GlobalAssemblyInfo.cs</Link>
     </Compile>
     <Compile Include="Framework\Content\ContentCache.cs" />
+    <Compile Include="Framework\LegacyManifestVersion.cs" />
     <Compile Include="Framework\Models\ModCompatibility.cs" />
     <Compile Include="Framework\ModLoading\Finders\EventFinder.cs" />
     <Compile Include="Framework\ModLoading\Finders\FieldFinder.cs" />
-- 
cgit 


From 0122abaf203c1efa70e5e48336cc4800d4f01cc0 Mon Sep 17 00:00:00 2001
From: Jesse Plamondon-Willard <github@jplamondonw.com>
Date: Tue, 16 Jan 2018 19:16:58 -0500
Subject: add JSON converters for crossplatform-incompatible types (#423)

---
 docs/release-notes.md                              |  7 +-
 .../Framework/Serialisation/ColorConverter.cs      | 82 +++++++++++++++++++++
 src/SMAPI/Framework/Serialisation/JsonHelper.cs    |  8 ++-
 .../Framework/Serialisation/PointConverter.cs      | 79 ++++++++++++++++++++
 .../Framework/Serialisation/RectangleConverter.cs  | 84 ++++++++++++++++++++++
 src/SMAPI/StardewModdingAPI.csproj                 |  3 +
 6 files changed, 260 insertions(+), 3 deletions(-)
 create mode 100644 src/SMAPI/Framework/Serialisation/ColorConverter.cs
 create mode 100644 src/SMAPI/Framework/Serialisation/PointConverter.cs
 create mode 100644 src/SMAPI/Framework/Serialisation/RectangleConverter.cs

(limited to 'docs')

diff --git a/docs/release-notes.md b/docs/release-notes.md
index 4b6a7ba5..c4a96b95 100644
--- a/docs/release-notes.md
+++ b/docs/release-notes.md
@@ -1,9 +1,12 @@
 # Release notes
 ## 2.4
 * For players:
-  * SMAPI now fixes curly quotes in `config.json` if possible.
+  * Fixed error parsing `config.json` files containing curly quotes.
+  * Fixed error parsing JSON files generated on another platform.
+  * Fixed rare issues caused by mods reloading core assemblies, which is no longer allowed.
+
+* For mod authors:
   * Fixed semantic versions always ignoring `-0` tag.
-  * Fixed rare issues caused by assembly references being incorrectly loaded twice.
 
 * For the [log parser][]:
   * Fixed parse error for logs with zero installed mods.
diff --git a/src/SMAPI/Framework/Serialisation/ColorConverter.cs b/src/SMAPI/Framework/Serialisation/ColorConverter.cs
new file mode 100644
index 00000000..d29f73b8
--- /dev/null
+++ b/src/SMAPI/Framework/Serialisation/ColorConverter.cs
@@ -0,0 +1,82 @@
+using System;
+using Microsoft.Xna.Framework;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using StardewModdingAPI.Framework.Exceptions;
+
+namespace StardewModdingAPI.Framework.Serialisation
+{
+    /// <summary>Handles deserialisation of <see cref="Color"/> for crossplatform compatibility.</summary>
+    internal class ColorConverter : JsonConverter
+    {
+        /*********
+        ** Accessors
+        *********/
+        /// <summary>Whether this converter can write JSON.</summary>
+        public override bool CanWrite => false;
+
+
+        /*********
+        ** Public methods
+        *********/
+        /// <summary>Get whether this instance can convert the specified object type.</summary>
+        /// <param name="objectType">The object type.</param>
+        public override bool CanConvert(Type objectType)
+        {
+            return objectType == typeof(Color);
+        }
+
+        /// <summary>Reads the JSON representation of the object.</summary>
+        /// <param name="reader">The JSON reader.</param>
+        /// <param name="objectType">The object type.</param>
+        /// <param name="existingValue">The object being read.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
+        {
+            //    Linux/Mac: { "B": 76, "G": 51, "R": 25, "A": 102 }
+            //    Windows:   "26, 51, 76, 102"
+            JToken token = JToken.Load(reader);
+            switch (token.Type)
+            {
+                case JTokenType.Object:
+                    {
+                        JObject obj = (JObject)token;
+                        int r = obj.Value<int>(nameof(Color.R));
+                        int g = obj.Value<int>(nameof(Color.G));
+                        int b = obj.Value<int>(nameof(Color.B));
+                        int a = obj.Value<int>(nameof(Color.A));
+                        return new Color(r, g, b, a);
+                    }
+
+                case JTokenType.String:
+                    {
+                        string str = token.Value<string>();
+                        if (string.IsNullOrWhiteSpace(str))
+                            return null;
+
+                        string[] parts = str.Split(',');
+                        if (parts.Length != 4)
+                            throw new SParseException($"Can't parse {typeof(Color).Name} from {token.Path}, invalid value '{str}'.");
+
+                        int r = Convert.ToInt32(parts[0]);
+                        int g = Convert.ToInt32(parts[1]);
+                        int b = Convert.ToInt32(parts[2]);
+                        int a = Convert.ToInt32(parts[3]);
+                        return new Color(r, g, b, a);
+                    }
+
+                default:
+                    throw new SParseException($"Can't parse {typeof(Point).Name} from {token.Path}, must be an object or string.");
+            }
+        }
+
+        /// <summary>Writes the JSON representation of the object.</summary>
+        /// <param name="writer">The JSON writer.</param>
+        /// <param name="value">The value.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
+        {
+            throw new InvalidOperationException("This converter does not write JSON.");
+        }
+    }
+}
diff --git a/src/SMAPI/Framework/Serialisation/JsonHelper.cs b/src/SMAPI/Framework/Serialisation/JsonHelper.cs
index 7c4e3ee3..f66f9dfb 100644
--- a/src/SMAPI/Framework/Serialisation/JsonHelper.cs
+++ b/src/SMAPI/Framework/Serialisation/JsonHelper.cs
@@ -19,9 +19,15 @@ namespace StardewModdingAPI.Framework.Serialisation
             ObjectCreationHandling = ObjectCreationHandling.Replace, // avoid issue where default ICollection<T> values are duplicated each time the config is loaded
             Converters = new List<JsonConverter>
             {
+                // enums
                 new StringEnumConverter<Buttons>(),
                 new StringEnumConverter<Keys>(),
-                new StringEnumConverter<SButton>()
+                new StringEnumConverter<SButton>(),
+
+                // crossplatform compatibility
+                new ColorConverter(),
+                new PointConverter(),
+                new RectangleConverter()
             }
         };
 
diff --git a/src/SMAPI/Framework/Serialisation/PointConverter.cs b/src/SMAPI/Framework/Serialisation/PointConverter.cs
new file mode 100644
index 00000000..d35660be
--- /dev/null
+++ b/src/SMAPI/Framework/Serialisation/PointConverter.cs
@@ -0,0 +1,79 @@
+using System;
+using Microsoft.Xna.Framework;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using StardewModdingAPI.Framework.Exceptions;
+
+namespace StardewModdingAPI.Framework.Serialisation
+{
+    /// <summary>Handles deserialisation of <see cref="PointConverter"/> for crossplatform compatibility.</summary>
+    internal class PointConverter : JsonConverter
+    {
+        /*********
+        ** Accessors
+        *********/
+        /// <summary>Whether this converter can write JSON.</summary>
+        public override bool CanWrite => false;
+
+
+        /*********
+        ** Public methods
+        *********/
+        /// <summary>Get whether this instance can convert the specified object type.</summary>
+        /// <param name="objectType">The object type.</param>
+        public override bool CanConvert(Type objectType)
+        {
+            return objectType == typeof(Point);
+        }
+
+        /// <summary>Reads the JSON representation of the object.</summary>
+        /// <param name="reader">The JSON reader.</param>
+        /// <param name="objectType">The object type.</param>
+        /// <param name="existingValue">The object being read.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
+        {
+            // point
+            //    Linux/Mac: { "X": 1, "Y": 2 }
+            //    Windows:   "1, 2"
+            JToken token = JToken.Load(reader);
+            switch (token.Type)
+            {
+                case JTokenType.Object:
+                    {
+                        JObject obj = (JObject)token;
+                        int x = obj.Value<int>(nameof(Point.X));
+                        int y = obj.Value<int>(nameof(Point.Y));
+                        return new Point(x, y);
+                    }
+
+                case JTokenType.String:
+                    {
+                        string str = token.Value<string>();
+                        if (string.IsNullOrWhiteSpace(str))
+                            return null;
+
+                        string[] parts = str.Split(',');
+                        if (parts.Length != 2)
+                            throw new SParseException($"Can't parse {typeof(Point).Name} from {token.Path}, invalid value '{str}'.");
+
+                        int x = Convert.ToInt32(parts[0]);
+                        int y = Convert.ToInt32(parts[1]);
+                        return new Point(x, y);
+                    }
+
+                default:
+                    throw new SParseException($"Can't parse {typeof(Point).Name} from {token.Path}, must be an object or string.");
+            }
+        }
+
+        /// <summary>Writes the JSON representation of the object.</summary>
+        /// <param name="writer">The JSON writer.</param>
+        /// <param name="value">The value.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
+        {
+            throw new InvalidOperationException("This converter does not write JSON.");
+        }
+    }
+}
diff --git a/src/SMAPI/Framework/Serialisation/RectangleConverter.cs b/src/SMAPI/Framework/Serialisation/RectangleConverter.cs
new file mode 100644
index 00000000..74df54e2
--- /dev/null
+++ b/src/SMAPI/Framework/Serialisation/RectangleConverter.cs
@@ -0,0 +1,84 @@
+using System;
+using System.Text.RegularExpressions;
+using Microsoft.Xna.Framework;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using StardewModdingAPI.Framework.Exceptions;
+
+namespace StardewModdingAPI.Framework.Serialisation
+{
+    /// <summary>Handles deserialisation of <see cref="Rectangle"/> for crossplatform compatibility.</summary>
+    internal class RectangleConverter : JsonConverter
+    {
+        /*********
+        ** Accessors
+        *********/
+        /// <summary>Whether this converter can write JSON.</summary>
+        public override bool CanWrite => false;
+
+
+        /*********
+        ** Public methods
+        *********/
+        /// <summary>Get whether this instance can convert the specified object type.</summary>
+        /// <param name="objectType">The object type.</param>
+        public override bool CanConvert(Type objectType)
+        {
+            return objectType == typeof(Rectangle);
+        }
+
+        /// <summary>Reads the JSON representation of the object.</summary>
+        /// <param name="reader">The JSON reader.</param>
+        /// <param name="objectType">The object type.</param>
+        /// <param name="existingValue">The object being read.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
+        {
+            //    Linux/Mac: { "X": 1, "Y": 2, "Width": 3, "Height": 4 }
+            //    Windows:   "{X:1 Y:2 Width:3 Height:4}"
+            JToken token = JToken.Load(reader);
+            switch (token.Type)
+            {
+                case JTokenType.Object:
+                    {
+                        JObject obj = (JObject)token;
+                        int x = obj.Value<int>(nameof(Rectangle.X));
+                        int y = obj.Value<int>(nameof(Rectangle.Y));
+                        int width = obj.Value<int>(nameof(Rectangle.Width));
+                        int height = obj.Value<int>(nameof(Rectangle.Height));
+                        return new Rectangle(x, y, width, height);
+                    }
+
+                case JTokenType.String:
+                    {
+                        string str = token.Value<string>();
+                        if (string.IsNullOrWhiteSpace(str))
+                            return Rectangle.Empty;
+
+                        var match = Regex.Match(str, @"^\{X:(?<x>\d+) Y:(?<y>\d+) Width:(?<width>\d+) Height:(?<height>\d+)\}$");
+                        if (!match.Success)
+                            throw new SParseException($"Can't parse {typeof(Rectangle).Name} from {reader.Path}, invalid string format.");
+
+                        int x = Convert.ToInt32(match.Groups["x"].Value);
+                        int y = Convert.ToInt32(match.Groups["y"].Value);
+                        int width = Convert.ToInt32(match.Groups["width"].Value);
+                        int height = Convert.ToInt32(match.Groups["height"].Value);
+
+                        return new Rectangle(x, y, width, height);
+                    }
+
+                default:
+                    throw new SParseException($"Can't parse {typeof(Rectangle).Name} from {reader.Path}, must be an object or string.");
+            }
+        }
+
+        /// <summary>Writes the JSON representation of the object.</summary>
+        /// <param name="writer">The JSON writer.</param>
+        /// <param name="value">The value.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
+        {
+            throw new InvalidOperationException("This converter does not write JSON.");
+        }
+    }
+}
diff --git a/src/SMAPI/StardewModdingAPI.csproj b/src/SMAPI/StardewModdingAPI.csproj
index c9c302f5..0625711c 100644
--- a/src/SMAPI/StardewModdingAPI.csproj
+++ b/src/SMAPI/StardewModdingAPI.csproj
@@ -108,6 +108,9 @@
     <Compile Include="Framework\Exceptions\SAssemblyLoadFailedException.cs" />
     <Compile Include="Framework\ModLoading\AssemblyLoadStatus.cs" />
     <Compile Include="Framework\Reflection\InterfaceProxyBuilder.cs" />
+    <Compile Include="Framework\Serialisation\RectangleConverter.cs" />
+    <Compile Include="Framework\Serialisation\ColorConverter.cs" />
+    <Compile Include="Framework\Serialisation\PointConverter.cs" />
     <Compile Include="Framework\Utilities\ContextHash.cs" />
     <Compile Include="IReflectedField.cs" />
     <Compile Include="IReflectedMethod.cs" />
-- 
cgit 


From a59572ee4eb64b075836247b92401c0fb554b6f0 Mon Sep 17 00:00:00 2001
From: Jesse Plamondon-Willard <github@jplamondonw.com>
Date: Wed, 17 Jan 2018 00:20:24 -0500
Subject: overhaul input handling (#422)

---
 docs/release-notes.md                    |  12 +-
 src/SMAPI/Framework/Input/InputState.cs  | 163 +++++++++++++++++++++++++++
 src/SMAPI/Framework/Input/InputStatus.cs |  29 +++++
 src/SMAPI/Framework/SGame.cs             | 186 ++++++++-----------------------
 src/SMAPI/SButton.cs                     |  15 +++
 src/SMAPI/StardewModdingAPI.csproj       |   2 +
 6 files changed, 266 insertions(+), 141 deletions(-)
 create mode 100644 src/SMAPI/Framework/Input/InputState.cs
 create mode 100644 src/SMAPI/Framework/Input/InputStatus.cs

(limited to 'docs')

diff --git a/docs/release-notes.md b/docs/release-notes.md
index c4a96b95..dd9f0352 100644
--- a/docs/release-notes.md
+++ b/docs/release-notes.md
@@ -5,12 +5,18 @@
   * Fixed error parsing JSON files generated on another platform.
   * Fixed rare issues caused by mods reloading core assemblies, which is no longer allowed.
 
-* For mod authors:
-  * Fixed semantic versions always ignoring `-0` tag.
-
 * For the [log parser][]:
   * Fixed parse error for logs with zero installed mods.
 
+* For modders:
+  * Added `SButton` `IsActionButton()` and `IsUseToolButton()` extensions.
+  * Fixed input events not recognising controller input as an action or use-tool button.
+  * Fixed input events setting the same `IsActionButton` and `IsUseToolButton` values for all buttons pressed in an update tick.
+  * Fixed semantic versions always ignoring `-0` tag.
+
+* For SMAPI developers:
+  * Overhauled input handling to support future input events.
+
 ## 2.3
 * For players:
   * Added a user-friendly [download page](https://smapi.io).
diff --git a/src/SMAPI/Framework/Input/InputState.cs b/src/SMAPI/Framework/Input/InputState.cs
new file mode 100644
index 00000000..8b0108ae
--- /dev/null
+++ b/src/SMAPI/Framework/Input/InputState.cs
@@ -0,0 +1,163 @@
+using System.Collections.Generic;
+using System.Linq;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Input;
+using StardewValley;
+
+namespace StardewModdingAPI.Framework.Input
+{
+    /// <summary>A summary of input changes during an update frame.</summary>
+    internal class InputState
+    {
+        /*********
+        ** Accessors
+        *********/
+        /// <summary>The underlying controller state.</summary>
+        public GamePadState ControllerState { get; }
+
+        /// <summary>The underlying keyboard state.</summary>
+        public KeyboardState KeyboardState { get; }
+
+        /// <summary>The underlying mouse state.</summary>
+        public MouseState MouseState { get; }
+
+        /// <summary>The mouse position on the screen adjusted for the zoom level.</summary>
+        public Point MousePosition { get; }
+
+        /// <summary>The buttons which were pressed, held, or released.</summary>
+        public IDictionary<SButton, InputStatus> ActiveButtons { get; } = new Dictionary<SButton, InputStatus>();
+
+
+        /*********
+        ** Public methods
+        *********/
+        /// <summary>Construct an empty instance.</summary>
+        public InputState() { }
+
+        /// <summary>Construct an instance.</summary>
+        /// <param name="previousState">The previous input state.</param>
+        /// <param name="controllerState">The current controller state.</param>
+        /// <param name="keyboardState">The current keyboard state.</param>
+        /// <param name="mouseState">The current mouse state.</param>
+        public InputState(InputState previousState, GamePadState controllerState, KeyboardState keyboardState, MouseState mouseState)
+        {
+            // init properties
+            this.ControllerState = controllerState;
+            this.KeyboardState = keyboardState;
+            this.MouseState = mouseState;
+            this.MousePosition = new Point((int)(mouseState.X * (1.0 / Game1.options.zoomLevel)), (int)(mouseState.Y * (1.0 / Game1.options.zoomLevel))); // derived from Game1::getMouseX
+
+            // get button states
+            SButton[] down = InputState.GetPressedButtons(keyboardState, mouseState, controllerState).ToArray();
+            foreach (SButton button in down)
+                this.ActiveButtons[button] = this.GetStatus(previousState.GetStatus(button), isDown: true);
+            foreach (KeyValuePair<SButton, InputStatus> prev in previousState.ActiveButtons)
+            {
+                if (prev.Value.IsDown() && !this.ActiveButtons.ContainsKey(prev.Key))
+                    this.ActiveButtons[prev.Key] = InputStatus.Released;
+            }
+        }
+
+        /// <summary>Get the status of a button.</summary>
+        /// <param name="button">The button to check.</param>
+        public InputStatus GetStatus(SButton button)
+        {
+            return this.ActiveButtons.TryGetValue(button, out InputStatus status) ? status : InputStatus.None;
+        }
+
+        /// <summary>Get whether a given button was pressed or held.</summary>
+        /// <param name="button">The button to check.</param>
+        public bool IsDown(SButton button)
+        {
+            return this.GetStatus(button).IsDown();
+        }
+
+        /// <summary>Get the current input state.</summary>
+        /// <param name="previousState">The previous input state.</param>
+        public static InputState GetState(InputState previousState)
+        {
+            GamePadState controllerState = GamePad.GetState(PlayerIndex.One);
+            KeyboardState keyboardState = Keyboard.GetState();
+            MouseState mouseState = Mouse.GetState();
+
+            return new InputState(previousState, controllerState, keyboardState, mouseState);
+        }
+
+        /*********
+        ** Private methods
+        *********/
+        /// <summary>Get the status of a button.</summary>
+        /// <param name="oldStatus">The previous button status.</param>
+        /// <param name="isDown">Whether the button is currently down.</param>
+        public InputStatus GetStatus(InputStatus oldStatus, bool isDown)
+        {
+            if (isDown && oldStatus.IsDown())
+                return InputStatus.Held;
+            if (isDown)
+                return InputStatus.Pressed;
+            return InputStatus.Released;
+        }
+
+        /// <summary>Get the buttons pressed in the given stats.</summary>
+        /// <param name="keyboard">The keyboard state.</param>
+        /// <param name="mouse">The mouse state.</param>
+        /// <param name="controller">The controller state.</param>
+        private static IEnumerable<SButton> GetPressedButtons(KeyboardState keyboard, MouseState mouse, GamePadState controller)
+        {
+            // keyboard
+            foreach (Keys key in keyboard.GetPressedKeys())
+                yield return key.ToSButton();
+
+            // mouse
+            if (mouse.LeftButton == ButtonState.Pressed)
+                yield return SButton.MouseLeft;
+            if (mouse.RightButton == ButtonState.Pressed)
+                yield return SButton.MouseRight;
+            if (mouse.MiddleButton == ButtonState.Pressed)
+                yield return SButton.MouseMiddle;
+            if (mouse.XButton1 == ButtonState.Pressed)
+                yield return SButton.MouseX1;
+            if (mouse.XButton2 == ButtonState.Pressed)
+                yield return SButton.MouseX2;
+
+            // controller
+            if (controller.IsConnected)
+            {
+                if (controller.Buttons.A == ButtonState.Pressed)
+                    yield return SButton.ControllerA;
+                if (controller.Buttons.B == ButtonState.Pressed)
+                    yield return SButton.ControllerB;
+                if (controller.Buttons.Back == ButtonState.Pressed)
+                    yield return SButton.ControllerBack;
+                if (controller.Buttons.BigButton == ButtonState.Pressed)
+                    yield return SButton.BigButton;
+                if (controller.Buttons.LeftShoulder == ButtonState.Pressed)
+                    yield return SButton.LeftShoulder;
+                if (controller.Buttons.LeftStick == ButtonState.Pressed)
+                    yield return SButton.LeftStick;
+                if (controller.Buttons.RightShoulder == ButtonState.Pressed)
+                    yield return SButton.RightShoulder;
+                if (controller.Buttons.RightStick == ButtonState.Pressed)
+                    yield return SButton.RightStick;
+                if (controller.Buttons.Start == ButtonState.Pressed)
+                    yield return SButton.ControllerStart;
+                if (controller.Buttons.X == ButtonState.Pressed)
+                    yield return SButton.ControllerX;
+                if (controller.Buttons.Y == ButtonState.Pressed)
+                    yield return SButton.ControllerY;
+                if (controller.DPad.Up == ButtonState.Pressed)
+                    yield return SButton.DPadUp;
+                if (controller.DPad.Down == ButtonState.Pressed)
+                    yield return SButton.DPadDown;
+                if (controller.DPad.Left == ButtonState.Pressed)
+                    yield return SButton.DPadLeft;
+                if (controller.DPad.Right == ButtonState.Pressed)
+                    yield return SButton.DPadRight;
+                if (controller.Triggers.Left > 0.2f)
+                    yield return SButton.LeftTrigger;
+                if (controller.Triggers.Right > 0.2f)
+                    yield return SButton.RightTrigger;
+            }
+        }
+    }
+}
diff --git a/src/SMAPI/Framework/Input/InputStatus.cs b/src/SMAPI/Framework/Input/InputStatus.cs
new file mode 100644
index 00000000..99b0006c
--- /dev/null
+++ b/src/SMAPI/Framework/Input/InputStatus.cs
@@ -0,0 +1,29 @@
+namespace StardewModdingAPI.Framework.Input
+{
+    /// <summary>The input status for a button during an update frame.</summary>
+    internal enum InputStatus
+    {
+        /// <summary>The button was neither pressed, held, nor released.</summary>
+        None,
+
+        /// <summary>The button was pressed in this frame.</summary>
+        Pressed,
+
+        /// <summary>The button has been held since the last frame.</summary>
+        Held,
+
+        /// <summary>The button was released in this frame.</summary>
+        Released
+    }
+
+    /// <summary>Extension methods for <see cref="InputStatus"/>.</summary>
+    internal static class InputStatusExtensions
+    {
+        /// <summary>Whether the button was pressed or held.</summary>
+        /// <param name="status">The button status.</param>
+        public static bool IsDown(this InputStatus status)
+        {
+            return status == InputStatus.Held || status == InputStatus.Pressed;
+        }
+    }
+}
diff --git a/src/SMAPI/Framework/SGame.cs b/src/SMAPI/Framework/SGame.cs
index 0a614f17..4a17926c 100644
--- a/src/SMAPI/Framework/SGame.cs
+++ b/src/SMAPI/Framework/SGame.cs
@@ -10,6 +10,7 @@ using Microsoft.Xna.Framework;
 using Microsoft.Xna.Framework.Graphics;
 using Microsoft.Xna.Framework.Input;
 using StardewModdingAPI.Events;
+using StardewModdingAPI.Framework.Input;
 using StardewModdingAPI.Framework.Reflection;
 using StardewModdingAPI.Framework.Utilities;
 using StardewValley;
@@ -53,20 +54,8 @@ namespace StardewModdingAPI.Framework
         /****
         ** Game state
         ****/
-        /// <summary>A record of the buttons pressed as of the previous tick.</summary>
-        private SButton[] PreviousPressedButtons = new SButton[0];
-
-        /// <summary>A record of the keyboard state (i.e. the up/down state for each button) as of the previous tick.</summary>
-        private KeyboardState PreviousKeyState;
-
-        /// <summary>A record of the controller state (i.e. the up/down state for each button) as of the previous tick.</summary>
-        private GamePadState PreviousControllerState;
-
-        /// <summary>A record of the mouse state (i.e. the cursor position, scroll amount, and the up/down state for each button) as of the previous tick.</summary>
-        private MouseState PreviousMouseState;
-
-        /// <summary>The previous mouse position on the screen adjusted for the zoom level.</summary>
-        private Point PreviousMousePosition;
+        /// <summary>The player input as of the previous tick.</summary>
+        private InputState PreviousInput = new InputState();
 
         /// <summary>The window size value at last check.</summary>
         private Point PreviousWindowSize;
@@ -348,34 +337,17 @@ namespace StardewModdingAPI.Framework
                 *********/
                 if (Game1.game1.IsActive)
                 {
-                    // get latest state
-                    KeyboardState keyState;
-                    GamePadState controllerState;
-                    MouseState mouseState;
-                    Point mousePosition;
+                    // get input state
+                    InputState inputState;
                     try
                     {
-                        keyState = Keyboard.GetState();
-                        controllerState = GamePad.GetState(PlayerIndex.One);
-                        mouseState = Mouse.GetState();
-                        mousePosition = new Point(Game1.getMouseX(), Game1.getMouseY());
+                        inputState = InputState.GetState(this.PreviousInput);
                     }
                     catch (InvalidOperationException) // GetState() may crash for some players if window doesn't have focus but game1.IsActive == true
                     {
-                        keyState = this.PreviousKeyState;
-                        controllerState = this.PreviousControllerState;
-                        mouseState = this.PreviousMouseState;
-                        mousePosition = this.PreviousMousePosition;
+                        inputState = this.PreviousInput;
                     }
 
-                    // analyse state
-                    SButton[] currentlyPressedKeys = this.GetPressedButtons(keyState, mouseState, controllerState).ToArray();
-                    SButton[] previousPressedKeys = this.PreviousPressedButtons;
-                    SButton[] framePressedKeys = currentlyPressedKeys.Except(previousPressedKeys).ToArray();
-                    SButton[] frameReleasedKeys = previousPressedKeys.Except(currentlyPressedKeys).ToArray();
-                    bool isUseToolButton = Game1.options.useToolButton.Any(p => framePressedKeys.Contains(p.ToSButton()));
-                    bool isActionButton = !isUseToolButton && Game1.options.actionButton.Any(p => framePressedKeys.Contains(p.ToSButton()));
-
                     // get cursor position
                     ICursorPosition cursor;
                     {
@@ -388,60 +360,58 @@ namespace StardewModdingAPI.Framework
                         cursor = new CursorPosition(screenPixels, tile, grabTile);
                     }
 
-                    // raise button pressed
-                    foreach (SButton button in framePressedKeys)
+                    // raise input events
+                    foreach (var pair in inputState.ActiveButtons)
                     {
-                        InputEvents.InvokeButtonPressed(this.Monitor, button, cursor, isActionButton, isUseToolButton);
+                        SButton button = pair.Key;
+                        InputStatus status = pair.Value;
 
-                        // legacy events
-                        if (button.TryGetKeyboard(out Keys key))
-                        {
-                            if (key != Keys.None)
-                                ControlEvents.InvokeKeyPressed(this.Monitor, key);
-                        }
-                        else if (button.TryGetController(out Buttons controllerButton))
+                        if (status == InputStatus.Pressed)
                         {
-                            if (controllerButton == Buttons.LeftTrigger || controllerButton == Buttons.RightTrigger)
-                                ControlEvents.InvokeTriggerPressed(this.Monitor, controllerButton, controllerButton == Buttons.LeftTrigger ? controllerState.Triggers.Left : controllerState.Triggers.Right);
-                            else
-                                ControlEvents.InvokeButtonPressed(this.Monitor, controllerButton);
-                        }
-                    }
+                            InputEvents.InvokeButtonPressed(this.Monitor, button, cursor, button.IsActionButton(), button.IsUseToolButton());
 
-                    // raise button released
-                    foreach (SButton button in frameReleasedKeys)
-                    {
-                        bool wasUseToolButton = (from opt in Game1.options.useToolButton let optButton = opt.ToSButton() where optButton == button && framePressedKeys.Contains(optButton) select optButton).Any();
-                        bool wasActionButton = !wasUseToolButton && (from opt in Game1.options.actionButton let optButton = opt.ToSButton() where optButton == button && framePressedKeys.Contains(optButton) select optButton).Any();
-                        InputEvents.InvokeButtonReleased(this.Monitor, button, cursor, wasActionButton, wasUseToolButton);
-
-                        // legacy events
-                        if (button.TryGetKeyboard(out Keys key))
-                        {
-                            if (key != Keys.None)
-                                ControlEvents.InvokeKeyReleased(this.Monitor, key);
+                            // legacy events
+                            if (button.TryGetKeyboard(out Keys key))
+                            {
+                                if (key != Keys.None)
+                                    ControlEvents.InvokeKeyPressed(this.Monitor, key);
+                            }
+                            else if (button.TryGetController(out Buttons controllerButton))
+                            {
+                                if (controllerButton == Buttons.LeftTrigger || controllerButton == Buttons.RightTrigger)
+                                    ControlEvents.InvokeTriggerPressed(this.Monitor, controllerButton, controllerButton == Buttons.LeftTrigger ? inputState.ControllerState.Triggers.Left : inputState.ControllerState.Triggers.Right);
+                                else
+                                    ControlEvents.InvokeButtonPressed(this.Monitor, controllerButton);
+                            }
                         }
-                        else if (button.TryGetController(out Buttons controllerButton))
+                        else if (status == InputStatus.Released)
                         {
-                            if (controllerButton == Buttons.LeftTrigger || controllerButton == Buttons.RightTrigger)
-                                ControlEvents.InvokeTriggerReleased(this.Monitor, controllerButton, controllerButton == Buttons.LeftTrigger ? controllerState.Triggers.Left : controllerState.Triggers.Right);
-                            else
-                                ControlEvents.InvokeButtonReleased(this.Monitor, controllerButton);
+                            InputEvents.InvokeButtonReleased(this.Monitor, button, cursor, button.IsActionButton(), button.IsUseToolButton());
+
+                            // legacy events
+                            if (button.TryGetKeyboard(out Keys key))
+                            {
+                                if (key != Keys.None)
+                                    ControlEvents.InvokeKeyReleased(this.Monitor, key);
+                            }
+                            else if (button.TryGetController(out Buttons controllerButton))
+                            {
+                                if (controllerButton == Buttons.LeftTrigger || controllerButton == Buttons.RightTrigger)
+                                    ControlEvents.InvokeTriggerReleased(this.Monitor, controllerButton, controllerButton == Buttons.LeftTrigger ? inputState.ControllerState.Triggers.Left : inputState.ControllerState.Triggers.Right);
+                                else
+                                    ControlEvents.InvokeButtonReleased(this.Monitor, controllerButton);
+                            }
                         }
                     }
 
                     // raise legacy state-changed events
-                    if (keyState != this.PreviousKeyState)
-                        ControlEvents.InvokeKeyboardChanged(this.Monitor, this.PreviousKeyState, keyState);
-                    if (mouseState != this.PreviousMouseState)
-                        ControlEvents.InvokeMouseChanged(this.Monitor, this.PreviousMouseState, mouseState, this.PreviousMousePosition, mousePosition);
+                    if (inputState.KeyboardState != this.PreviousInput.KeyboardState)
+                        ControlEvents.InvokeKeyboardChanged(this.Monitor, this.PreviousInput.KeyboardState, inputState.KeyboardState);
+                    if (inputState.MouseState != this.PreviousInput.MouseState)
+                        ControlEvents.InvokeMouseChanged(this.Monitor, this.PreviousInput.MouseState, inputState.MouseState, this.PreviousInput.MousePosition, inputState.MousePosition);
 
                     // track state
-                    this.PreviousMouseState = mouseState;
-                    this.PreviousMousePosition = mousePosition;
-                    this.PreviousKeyState = keyState;
-                    this.PreviousControllerState = controllerState;
-                    this.PreviousPressedButtons = currentlyPressedKeys;
+                    this.PreviousInput = inputState;
                 }
 
                 /*********
@@ -1304,67 +1274,7 @@ namespace StardewModdingAPI.Framework
             this.PreviousSaveID = 0;
         }
 
-        /// <summary>Get the buttons pressed in the given stats.</summary>
-        /// <param name="keyboard">The keyboard state.</param>
-        /// <param name="mouse">The mouse state.</param>
-        /// <param name="controller">The controller state.</param>
-        private IEnumerable<SButton> GetPressedButtons(KeyboardState keyboard, MouseState mouse, GamePadState controller)
-        {
-            // keyboard
-            foreach (Keys key in keyboard.GetPressedKeys())
-                yield return key.ToSButton();
-
-            // mouse
-            if (mouse.LeftButton == ButtonState.Pressed)
-                yield return SButton.MouseLeft;
-            if (mouse.RightButton == ButtonState.Pressed)
-                yield return SButton.MouseRight;
-            if (mouse.MiddleButton == ButtonState.Pressed)
-                yield return SButton.MouseMiddle;
-            if (mouse.XButton1 == ButtonState.Pressed)
-                yield return SButton.MouseX1;
-            if (mouse.XButton2 == ButtonState.Pressed)
-                yield return SButton.MouseX2;
-
-            // controller
-            if (controller.IsConnected)
-            {
-                if (controller.Buttons.A == ButtonState.Pressed)
-                    yield return SButton.ControllerA;
-                if (controller.Buttons.B == ButtonState.Pressed)
-                    yield return SButton.ControllerB;
-                if (controller.Buttons.Back == ButtonState.Pressed)
-                    yield return SButton.ControllerBack;
-                if (controller.Buttons.BigButton == ButtonState.Pressed)
-                    yield return SButton.BigButton;
-                if (controller.Buttons.LeftShoulder == ButtonState.Pressed)
-                    yield return SButton.LeftShoulder;
-                if (controller.Buttons.LeftStick == ButtonState.Pressed)
-                    yield return SButton.LeftStick;
-                if (controller.Buttons.RightShoulder == ButtonState.Pressed)
-                    yield return SButton.RightShoulder;
-                if (controller.Buttons.RightStick == ButtonState.Pressed)
-                    yield return SButton.RightStick;
-                if (controller.Buttons.Start == ButtonState.Pressed)
-                    yield return SButton.ControllerStart;
-                if (controller.Buttons.X == ButtonState.Pressed)
-                    yield return SButton.ControllerX;
-                if (controller.Buttons.Y == ButtonState.Pressed)
-                    yield return SButton.ControllerY;
-                if (controller.DPad.Up == ButtonState.Pressed)
-                    yield return SButton.DPadUp;
-                if (controller.DPad.Down == ButtonState.Pressed)
-                    yield return SButton.DPadDown;
-                if (controller.DPad.Left == ButtonState.Pressed)
-                    yield return SButton.DPadLeft;
-                if (controller.DPad.Right == ButtonState.Pressed)
-                    yield return SButton.DPadRight;
-                if (controller.Triggers.Left > 0.2f)
-                    yield return SButton.LeftTrigger;
-                if (controller.Triggers.Right > 0.2f)
-                    yield return SButton.RightTrigger;
-            }
-        }
+
 
         /// <summary>Get the player inventory changes between two states.</summary>
         /// <param name="current">The player's current inventory.</param>
diff --git a/src/SMAPI/SButton.cs b/src/SMAPI/SButton.cs
index bd6635c7..3f95169a 100644
--- a/src/SMAPI/SButton.cs
+++ b/src/SMAPI/SButton.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Linq;
 using Microsoft.Xna.Framework.Input;
 using StardewValley;
 
@@ -683,5 +684,19 @@ namespace StardewModdingAPI
             button = default(InputButton);
             return false;
         }
+
+        /// <summary>Get whether the given button is equivalent to <see cref="Options.useToolButton"/>.</summary>
+        /// <param name="input">The button.</param>
+        public static bool IsUseToolButton(this SButton input)
+        {
+            return input == SButton.ControllerX || Game1.options.useToolButton.Any(p => p.ToSButton() == input);
+        }
+
+        /// <summary>Get whether the given button is equivalent to <see cref="Options.actionButton"/>.</summary>
+        /// <param name="input">The button.</param>
+        public static bool IsActionButton(this SButton input)
+        {
+            return input == SButton.ControllerA || Game1.options.actionButton.Any(p => p.ToSButton() == input);
+        }
     }
 }
diff --git a/src/SMAPI/StardewModdingAPI.csproj b/src/SMAPI/StardewModdingAPI.csproj
index 0625711c..e02e1ab4 100644
--- a/src/SMAPI/StardewModdingAPI.csproj
+++ b/src/SMAPI/StardewModdingAPI.csproj
@@ -86,6 +86,8 @@
       <Link>Properties\GlobalAssemblyInfo.cs</Link>
     </Compile>
     <Compile Include="Framework\Content\ContentCache.cs" />
+    <Compile Include="Framework\Input\InputState.cs" />
+    <Compile Include="Framework\Input\InputStatus.cs" />
     <Compile Include="Framework\LegacyManifestVersion.cs" />
     <Compile Include="Framework\Models\ModCompatibility.cs" />
     <Compile Include="Framework\ModLoading\Finders\EventFinder.cs" />
-- 
cgit 


From 568ba2757e0b2947a8578128ff8f0a70eb075b38 Mon Sep 17 00:00:00 2001
From: Jesse Plamondon-Willard <github@jplamondonw.com>
Date: Fri, 19 Jan 2018 21:13:23 -0500
Subject: fix events being raised while the game is loading a save (#424)

---
 docs/release-notes.md        | 4 +++-
 src/SMAPI/Framework/SGame.cs | 7 +++++++
 2 files changed, 10 insertions(+), 1 deletion(-)

(limited to 'docs')

diff --git a/docs/release-notes.md b/docs/release-notes.md
index dd9f0352..d55ba5a1 100644
--- a/docs/release-notes.md
+++ b/docs/release-notes.md
@@ -1,15 +1,17 @@
 # Release notes
 ## 2.4
 * For players:
+  * Fixed graphical corruption in rare cases.
   * Fixed error parsing `config.json` files containing curly quotes.
   * Fixed error parsing JSON files generated on another platform.
-  * Fixed rare issues caused by mods reloading core assemblies, which is no longer allowed.
+  * Fixed error parsing some JSON files after mods reload core assemblies, which is no longer allowed.
 
 * For the [log parser][]:
   * Fixed parse error for logs with zero installed mods.
 
 * For modders:
   * Added `SButton` `IsActionButton()` and `IsUseToolButton()` extensions.
+  * Fixed events being raised while the game is loading a save file.
   * Fixed input events not recognising controller input as an action or use-tool button.
   * Fixed input events setting the same `IsActionButton` and `IsUseToolButton` values for all buttons pressed in an update tick.
   * Fixed semantic versions always ignoring `-0` tag.
diff --git a/src/SMAPI/Framework/SGame.cs b/src/SMAPI/Framework/SGame.cs
index 4a17926c..2eb2da99 100644
--- a/src/SMAPI/Framework/SGame.cs
+++ b/src/SMAPI/Framework/SGame.cs
@@ -229,6 +229,13 @@ namespace StardewModdingAPI.Framework
                     return;
                 }
 
+                // game is asynchronously loading a save, block mod events to avoid conflicts
+                if (Game1.gameMode == Game1.loadingMode)
+                {
+                    base.Update(gameTime);
+                    return;
+                }
+
                 /*********
                 ** Save events + suppress events during save
                 *********/
-- 
cgit 


From 32defd60e2e1ce4d153c567f75343111e4597684 Mon Sep 17 00:00:00 2001
From: Jesse Plamondon-Willard <github@jplamondonw.com>
Date: Fri, 19 Jan 2018 21:24:22 -0500
Subject: tweak new script, document workaround, update release notes

---
 docs/release-notes.md      | 1 +
 src/SMAPI/unix-launcher.sh | 5 ++++-
 2 files changed, 5 insertions(+), 1 deletion(-)

(limited to 'docs')

diff --git a/docs/release-notes.md b/docs/release-notes.md
index 4b6a7ba5..2f136509 100644
--- a/docs/release-notes.md
+++ b/docs/release-notes.md
@@ -4,6 +4,7 @@
   * SMAPI now fixes curly quotes in `config.json` if possible.
   * Fixed semantic versions always ignoring `-0` tag.
   * Fixed rare issues caused by assembly references being incorrectly loaded twice.
+  * Fixed error on Linux loading SMAPI when the default terminal is set to Terminator.
 
 * For the [log parser][]:
   * Fixed parse error for logs with zero installed mods.
diff --git a/src/SMAPI/unix-launcher.sh b/src/SMAPI/unix-launcher.sh
index 30021470..2542a286 100644
--- a/src/SMAPI/unix-launcher.sh
+++ b/src/SMAPI/unix-launcher.sh
@@ -63,7 +63,10 @@ else
 
     # open SMAPI in terminal
     if $COMMAND x-terminal-emulator 2>/dev/null; then
-        if [[ " $(readlink $(readlink /usr/bin/x-terminal-emulator))" == *"/terminator" ]]; then
+        # Terminator converts -e to -x when used through x-terminal-emulator for some reason (per
+        # `man terminator`), which causes an "unable to find shell" error. If x-terminal-emulator
+        # is mapped to Terminator, invoke it directly instead.
+        if [[ "$(readlink -e $(which x-terminal-emulator))" == *"/terminator" ]]; then
             terminator -e "$LAUNCHER"
         else
             x-terminal-emulator -e "$LAUNCHER"
-- 
cgit 


From 9636d5b3aac99459e5933bc4fa6ddb8ca84917af Mon Sep 17 00:00:00 2001
From: Jesse Plamondon-Willard <github@jplamondonw.com>
Date: Sat, 20 Jan 2018 21:26:21 -0500
Subject: encapsulate common JSON converter code, improve parse errors (#423)

---
 docs/release-notes.md                              |  1 +
 .../Framework/Serialisation/ColorConverter.cs      | 92 +++++++---------------
 src/SMAPI/Framework/Serialisation/JsonHelper.cs    | 13 ++-
 .../Framework/Serialisation/PointConverter.cs      | 83 ++++++-------------
 .../Framework/Serialisation/RectangleConverter.cs  | 91 +++++++--------------
 .../Serialisation/SimpleReadOnlyConverter.cs       | 77 ++++++++++++++++++
 src/SMAPI/StardewModdingAPI.csproj                 |  1 +
 7 files changed, 168 insertions(+), 190 deletions(-)
 create mode 100644 src/SMAPI/Framework/Serialisation/SimpleReadOnlyConverter.cs

(limited to 'docs')

diff --git a/docs/release-notes.md b/docs/release-notes.md
index 27110bff..31ceb7de 100644
--- a/docs/release-notes.md
+++ b/docs/release-notes.md
@@ -12,6 +12,7 @@
 
 * For modders:
   * Added `SButton` `IsActionButton()` and `IsUseToolButton()` extensions.
+  * Improved JSON parse errors to provide more useful info for troubleshooting.
   * Fixed events being raised while the game is loading a save file.
   * Fixed input events not recognising controller input as an action or use-tool button.
   * Fixed input events setting the same `IsActionButton` and `IsUseToolButton` values for all buttons pressed in an update tick.
diff --git a/src/SMAPI/Framework/Serialisation/ColorConverter.cs b/src/SMAPI/Framework/Serialisation/ColorConverter.cs
index d29f73b8..d2315a00 100644
--- a/src/SMAPI/Framework/Serialisation/ColorConverter.cs
+++ b/src/SMAPI/Framework/Serialisation/ColorConverter.cs
@@ -1,82 +1,46 @@
 using System;
 using Microsoft.Xna.Framework;
-using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 using StardewModdingAPI.Framework.Exceptions;
 
 namespace StardewModdingAPI.Framework.Serialisation
 {
     /// <summary>Handles deserialisation of <see cref="Color"/> for crossplatform compatibility.</summary>
-    internal class ColorConverter : JsonConverter
+    /// <remarks>
+    /// - Linux/Mac format: { "B": 76, "G": 51, "R": 25, "A": 102 }
+    /// - Windows format:   "26, 51, 76, 102"
+    /// </remarks>
+    internal class ColorConverter : SimpleReadOnlyConverter<Color>
     {
         /*********
-        ** Accessors
+        ** Protected methods
         *********/
-        /// <summary>Whether this converter can write JSON.</summary>
-        public override bool CanWrite => false;
-
-
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Get whether this instance can convert the specified object type.</summary>
-        /// <param name="objectType">The object type.</param>
-        public override bool CanConvert(Type objectType)
+        /// <summary>Read a JSON object.</summary>
+        /// <param name="obj">The JSON object to read.</param>
+        /// <param name="path">The path to the current JSON node.</param>
+        protected override Color ReadObject(JObject obj, string path)
         {
-            return objectType == typeof(Color);
-        }
-
-        /// <summary>Reads the JSON representation of the object.</summary>
-        /// <param name="reader">The JSON reader.</param>
-        /// <param name="objectType">The object type.</param>
-        /// <param name="existingValue">The object being read.</param>
-        /// <param name="serializer">The calling serializer.</param>
-        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
-        {
-            //    Linux/Mac: { "B": 76, "G": 51, "R": 25, "A": 102 }
-            //    Windows:   "26, 51, 76, 102"
-            JToken token = JToken.Load(reader);
-            switch (token.Type)
-            {
-                case JTokenType.Object:
-                    {
-                        JObject obj = (JObject)token;
-                        int r = obj.Value<int>(nameof(Color.R));
-                        int g = obj.Value<int>(nameof(Color.G));
-                        int b = obj.Value<int>(nameof(Color.B));
-                        int a = obj.Value<int>(nameof(Color.A));
-                        return new Color(r, g, b, a);
-                    }
-
-                case JTokenType.String:
-                    {
-                        string str = token.Value<string>();
-                        if (string.IsNullOrWhiteSpace(str))
-                            return null;
-
-                        string[] parts = str.Split(',');
-                        if (parts.Length != 4)
-                            throw new SParseException($"Can't parse {typeof(Color).Name} from {token.Path}, invalid value '{str}'.");
-
-                        int r = Convert.ToInt32(parts[0]);
-                        int g = Convert.ToInt32(parts[1]);
-                        int b = Convert.ToInt32(parts[2]);
-                        int a = Convert.ToInt32(parts[3]);
-                        return new Color(r, g, b, a);
-                    }
-
-                default:
-                    throw new SParseException($"Can't parse {typeof(Point).Name} from {token.Path}, must be an object or string.");
-            }
+            int r = obj.Value<int>(nameof(Color.R));
+            int g = obj.Value<int>(nameof(Color.G));
+            int b = obj.Value<int>(nameof(Color.B));
+            int a = obj.Value<int>(nameof(Color.A));
+            return new Color(r, g, b, a);
         }
 
-        /// <summary>Writes the JSON representation of the object.</summary>
-        /// <param name="writer">The JSON writer.</param>
-        /// <param name="value">The value.</param>
-        /// <param name="serializer">The calling serializer.</param>
-        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
+        /// <summary>Read a JSON string.</summary>
+        /// <param name="str">The JSON string value.</param>
+        /// <param name="path">The path to the current JSON node.</param>
+        protected override Color ReadString(string str, string path)
         {
-            throw new InvalidOperationException("This converter does not write JSON.");
+            string[] parts = str.Split(',');
+            if (parts.Length != 4)
+                throw new SParseException($"Can't parse {typeof(Color).Name} from invalid value '{str}' (path: {path}).");
+
+            int r = Convert.ToInt32(parts[0]);
+            int g = Convert.ToInt32(parts[1]);
+            int b = Convert.ToInt32(parts[2]);
+            int a = Convert.ToInt32(parts[3]);
+            return new Color(r, g, b, a);
         }
     }
 }
diff --git a/src/SMAPI/Framework/Serialisation/JsonHelper.cs b/src/SMAPI/Framework/Serialisation/JsonHelper.cs
index f66f9dfb..90a6d258 100644
--- a/src/SMAPI/Framework/Serialisation/JsonHelper.cs
+++ b/src/SMAPI/Framework/Serialisation/JsonHelper.cs
@@ -63,11 +63,16 @@ namespace StardewModdingAPI.Framework.Serialisation
             {
                 return this.Deserialise<TModel>(json);
             }
-            catch (JsonReaderException ex)
+            catch (Exception ex)
             {
-                string error = $"The file at {fullPath} doesn't seem to be valid JSON.";
-                if (json.Contains("“") || json.Contains("”"))
-                    error += " Found curly quotes in the text; note that only straight quotes are allowed in JSON.";
+                string error = $"Can't parse JSON file at {fullPath}.";
+
+                if (ex is JsonReaderException)
+                {
+                    error += " This doesn't seem to be valid JSON.";
+                    if (json.Contains("“") || json.Contains("”"))
+                        error += " Found curly quotes in the text; note that only straight quotes are allowed in JSON.";
+                }
                 error += $"\nTechnical details: {ex.Message}";
                 throw new JsonReaderException(error);
             }
diff --git a/src/SMAPI/Framework/Serialisation/PointConverter.cs b/src/SMAPI/Framework/Serialisation/PointConverter.cs
index d35660be..bdcefaa5 100644
--- a/src/SMAPI/Framework/Serialisation/PointConverter.cs
+++ b/src/SMAPI/Framework/Serialisation/PointConverter.cs
@@ -1,79 +1,42 @@
 using System;
 using Microsoft.Xna.Framework;
-using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 using StardewModdingAPI.Framework.Exceptions;
 
 namespace StardewModdingAPI.Framework.Serialisation
 {
     /// <summary>Handles deserialisation of <see cref="PointConverter"/> for crossplatform compatibility.</summary>
-    internal class PointConverter : JsonConverter
+    /// <remarks>
+    /// - Linux/Mac format: { "X": 1, "Y": 2 }
+    /// - Windows format:   "1, 2"
+    /// </remarks>
+    internal class PointConverter : SimpleReadOnlyConverter<Point>
     {
         /*********
-        ** Accessors
+        ** Protected methods
         *********/
-        /// <summary>Whether this converter can write JSON.</summary>
-        public override bool CanWrite => false;
-
-
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Get whether this instance can convert the specified object type.</summary>
-        /// <param name="objectType">The object type.</param>
-        public override bool CanConvert(Type objectType)
+        /// <summary>Read a JSON object.</summary>
+        /// <param name="obj">The JSON object to read.</param>
+        /// <param name="path">The path to the current JSON node.</param>
+        protected override Point ReadObject(JObject obj, string path)
         {
-            return objectType == typeof(Point);
+            int x = obj.Value<int>(nameof(Point.X));
+            int y = obj.Value<int>(nameof(Point.Y));
+            return new Point(x, y);
         }
 
-        /// <summary>Reads the JSON representation of the object.</summary>
-        /// <param name="reader">The JSON reader.</param>
-        /// <param name="objectType">The object type.</param>
-        /// <param name="existingValue">The object being read.</param>
-        /// <param name="serializer">The calling serializer.</param>
-        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
+        /// <summary>Read a JSON string.</summary>
+        /// <param name="str">The JSON string value.</param>
+        /// <param name="path">The path to the current JSON node.</param>
+        protected override Point ReadString(string str, string path)
         {
-            // point
-            //    Linux/Mac: { "X": 1, "Y": 2 }
-            //    Windows:   "1, 2"
-            JToken token = JToken.Load(reader);
-            switch (token.Type)
-            {
-                case JTokenType.Object:
-                    {
-                        JObject obj = (JObject)token;
-                        int x = obj.Value<int>(nameof(Point.X));
-                        int y = obj.Value<int>(nameof(Point.Y));
-                        return new Point(x, y);
-                    }
-
-                case JTokenType.String:
-                    {
-                        string str = token.Value<string>();
-                        if (string.IsNullOrWhiteSpace(str))
-                            return null;
+            string[] parts = str.Split(',');
+            if (parts.Length != 2)
+                throw new SParseException($"Can't parse {typeof(Point).Name} from invalid value '{str}' (path: {path}).");
 
-                        string[] parts = str.Split(',');
-                        if (parts.Length != 2)
-                            throw new SParseException($"Can't parse {typeof(Point).Name} from {token.Path}, invalid value '{str}'.");
-
-                        int x = Convert.ToInt32(parts[0]);
-                        int y = Convert.ToInt32(parts[1]);
-                        return new Point(x, y);
-                    }
-
-                default:
-                    throw new SParseException($"Can't parse {typeof(Point).Name} from {token.Path}, must be an object or string.");
-            }
-        }
-
-        /// <summary>Writes the JSON representation of the object.</summary>
-        /// <param name="writer">The JSON writer.</param>
-        /// <param name="value">The value.</param>
-        /// <param name="serializer">The calling serializer.</param>
-        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
-        {
-            throw new InvalidOperationException("This converter does not write JSON.");
+            int x = Convert.ToInt32(parts[0]);
+            int y = Convert.ToInt32(parts[1]);
+            return new Point(x, y);
         }
     }
 }
diff --git a/src/SMAPI/Framework/Serialisation/RectangleConverter.cs b/src/SMAPI/Framework/Serialisation/RectangleConverter.cs
index 74df54e2..bbf60435 100644
--- a/src/SMAPI/Framework/Serialisation/RectangleConverter.cs
+++ b/src/SMAPI/Framework/Serialisation/RectangleConverter.cs
@@ -1,84 +1,51 @@
 using System;
 using System.Text.RegularExpressions;
 using Microsoft.Xna.Framework;
-using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 using StardewModdingAPI.Framework.Exceptions;
 
 namespace StardewModdingAPI.Framework.Serialisation
 {
     /// <summary>Handles deserialisation of <see cref="Rectangle"/> for crossplatform compatibility.</summary>
-    internal class RectangleConverter : JsonConverter
+    /// <remarks>
+    /// - Linux/Mac format: { "X": 1, "Y": 2, "Width": 3, "Height": 4 }
+    /// - Windows format:   "{X:1 Y:2 Width:3 Height:4}"
+    /// </remarks>
+    internal class RectangleConverter : SimpleReadOnlyConverter<Rectangle>
     {
         /*********
-        ** Accessors
+        ** Protected methods
         *********/
-        /// <summary>Whether this converter can write JSON.</summary>
-        public override bool CanWrite => false;
-
-
-        /*********
-        ** Public methods
-        *********/
-        /// <summary>Get whether this instance can convert the specified object type.</summary>
-        /// <param name="objectType">The object type.</param>
-        public override bool CanConvert(Type objectType)
+        /// <summary>Read a JSON object.</summary>
+        /// <param name="obj">The JSON object to read.</param>
+        /// <param name="path">The path to the current JSON node.</param>
+        protected override Rectangle ReadObject(JObject obj, string path)
         {
-            return objectType == typeof(Rectangle);
+            int x = obj.Value<int>(nameof(Rectangle.X));
+            int y = obj.Value<int>(nameof(Rectangle.Y));
+            int width = obj.Value<int>(nameof(Rectangle.Width));
+            int height = obj.Value<int>(nameof(Rectangle.Height));
+            return new Rectangle(x, y, width, height);
         }
 
-        /// <summary>Reads the JSON representation of the object.</summary>
-        /// <param name="reader">The JSON reader.</param>
-        /// <param name="objectType">The object type.</param>
-        /// <param name="existingValue">The object being read.</param>
-        /// <param name="serializer">The calling serializer.</param>
-        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
+        /// <summary>Read a JSON string.</summary>
+        /// <param name="str">The JSON string value.</param>
+        /// <param name="path">The path to the current JSON node.</param>
+        protected override Rectangle ReadString(string str, string path)
         {
-            //    Linux/Mac: { "X": 1, "Y": 2, "Width": 3, "Height": 4 }
-            //    Windows:   "{X:1 Y:2 Width:3 Height:4}"
-            JToken token = JToken.Load(reader);
-            switch (token.Type)
-            {
-                case JTokenType.Object:
-                    {
-                        JObject obj = (JObject)token;
-                        int x = obj.Value<int>(nameof(Rectangle.X));
-                        int y = obj.Value<int>(nameof(Rectangle.Y));
-                        int width = obj.Value<int>(nameof(Rectangle.Width));
-                        int height = obj.Value<int>(nameof(Rectangle.Height));
-                        return new Rectangle(x, y, width, height);
-                    }
-
-                case JTokenType.String:
-                    {
-                        string str = token.Value<string>();
-                        if (string.IsNullOrWhiteSpace(str))
-                            return Rectangle.Empty;
+            if (string.IsNullOrWhiteSpace(str))
+                return Rectangle.Empty;
 
-                        var match = Regex.Match(str, @"^\{X:(?<x>\d+) Y:(?<y>\d+) Width:(?<width>\d+) Height:(?<height>\d+)\}$");
-                        if (!match.Success)
-                            throw new SParseException($"Can't parse {typeof(Rectangle).Name} from {reader.Path}, invalid string format.");
+            var match = Regex.Match(str, @"^\{X:(?<x>\d+) Y:(?<y>\d+) Width:(?<width>\d+) Height:(?<height>\d+)\}$");
+            if (!match.Success)
+                throw new SParseException($"Can't parse {typeof(Rectangle).Name} from invalid value '{str}' (path: {path}).");
 
-                        int x = Convert.ToInt32(match.Groups["x"].Value);
-                        int y = Convert.ToInt32(match.Groups["y"].Value);
-                        int width = Convert.ToInt32(match.Groups["width"].Value);
-                        int height = Convert.ToInt32(match.Groups["height"].Value);
+            int x = Convert.ToInt32(match.Groups["x"].Value);
+            int y = Convert.ToInt32(match.Groups["y"].Value);
+            int width = Convert.ToInt32(match.Groups["width"].Value);
+            int height = Convert.ToInt32(match.Groups["height"].Value);
 
-                        return new Rectangle(x, y, width, height);
-                    }
-
-                default:
-                    throw new SParseException($"Can't parse {typeof(Rectangle).Name} from {reader.Path}, must be an object or string.");
-            }
-        }
-
-        /// <summary>Writes the JSON representation of the object.</summary>
-        /// <param name="writer">The JSON writer.</param>
-        /// <param name="value">The value.</param>
-        /// <param name="serializer">The calling serializer.</param>
-        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
-        {
-            throw new InvalidOperationException("This converter does not write JSON.");
+            return new Rectangle(x, y, width, height);
         }
     }
 }
diff --git a/src/SMAPI/Framework/Serialisation/SimpleReadOnlyConverter.cs b/src/SMAPI/Framework/Serialisation/SimpleReadOnlyConverter.cs
new file mode 100644
index 00000000..9308456b
--- /dev/null
+++ b/src/SMAPI/Framework/Serialisation/SimpleReadOnlyConverter.cs
@@ -0,0 +1,77 @@
+using System;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using StardewModdingAPI.Framework.Exceptions;
+
+namespace StardewModdingAPI.Framework.Serialisation
+{
+    /// <summary>The base implementation for simplified converters which deserialise <typeparamref name="T"/> without overriding serialisation.</summary>
+    /// <typeparam name="T">The type to deserialise.</typeparam>
+    internal abstract class SimpleReadOnlyConverter<T> : JsonConverter
+    {
+        /*********
+        ** Accessors
+        *********/
+        /// <summary>Whether this converter can write JSON.</summary>
+        public override bool CanWrite => false;
+
+
+        /*********
+        ** Public methods
+        *********/
+        /// <summary>Get whether this instance can convert the specified object type.</summary>
+        /// <param name="objectType">The object type.</param>
+        public override bool CanConvert(Type objectType)
+        {
+            return objectType == typeof(T);
+        }
+
+        /// <summary>Writes the JSON representation of the object.</summary>
+        /// <param name="writer">The JSON writer.</param>
+        /// <param name="value">The value.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
+        {
+            throw new InvalidOperationException("This converter does not write JSON.");
+        }
+
+        /// <summary>Reads the JSON representation of the object.</summary>
+        /// <param name="reader">The JSON reader.</param>
+        /// <param name="objectType">The object type.</param>
+        /// <param name="existingValue">The object being read.</param>
+        /// <param name="serializer">The calling serializer.</param>
+        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
+        {
+            string path = reader.Path;
+            switch (reader.TokenType)
+            {
+                case JsonToken.StartObject:
+                    return this.ReadObject(JObject.Load(reader), path);
+                case JsonToken.String:
+                    return this.ReadString(JToken.Load(reader).Value<string>(), path);
+                default:
+                    throw new SParseException($"Can't parse {typeof(T).Name} from {reader.TokenType} (path: {reader.Path}).");
+            }
+        }
+
+
+        /*********
+        ** Protected methods
+        *********/
+        /// <summary>Read a JSON object.</summary>
+        /// <param name="obj">The JSON object to read.</param>
+        /// <param name="path">The path to the current JSON node.</param>
+        protected virtual T ReadObject(JObject obj, string path)
+        {
+            throw new SParseException($"Can't parse {typeof(T).Name} from object (path: {path}).");
+        }
+
+        /// <summary>Read a JSON string.</summary>
+        /// <param name="str">The JSON string value.</param>
+        /// <param name="path">The path to the current JSON node.</param>
+        protected virtual T ReadString(string str, string path)
+        {
+            throw new SParseException($"Can't parse {typeof(T).Name} from string (path: {path}).");
+        }
+    }
+}
diff --git a/src/SMAPI/StardewModdingAPI.csproj b/src/SMAPI/StardewModdingAPI.csproj
index e02e1ab4..dd4f6134 100644
--- a/src/SMAPI/StardewModdingAPI.csproj
+++ b/src/SMAPI/StardewModdingAPI.csproj
@@ -110,6 +110,7 @@
     <Compile Include="Framework\Exceptions\SAssemblyLoadFailedException.cs" />
     <Compile Include="Framework\ModLoading\AssemblyLoadStatus.cs" />
     <Compile Include="Framework\Reflection\InterfaceProxyBuilder.cs" />
+    <Compile Include="Framework\Serialisation\SimpleReadOnlyConverter.cs" />
     <Compile Include="Framework\Serialisation\RectangleConverter.cs" />
     <Compile Include="Framework\Serialisation\ColorConverter.cs" />
     <Compile Include="Framework\Serialisation\PointConverter.cs" />
-- 
cgit 


From b3318af7d0e40462563e6d98c0c15fac48bb6770 Mon Sep 17 00:00:00 2001
From: Jesse Plamondon-Willard <github@jplamondonw.com>
Date: Sat, 20 Jan 2018 23:14:39 -0500
Subject: update release notes

---
 docs/release-notes.md | 2 ++
 1 file changed, 2 insertions(+)

(limited to 'docs')

diff --git a/docs/release-notes.md b/docs/release-notes.md
index 31ceb7de..38fb680b 100644
--- a/docs/release-notes.md
+++ b/docs/release-notes.md
@@ -6,6 +6,7 @@
   * Fixed error parsing JSON files generated on another platform.
   * Fixed error parsing some JSON files after mods reload core assemblies, which is no longer allowed.
   * Fixed error on Linux loading SMAPI when the default terminal is set to Terminator.
+  * Fixed issue where Custom Farm Types couldn't initialise a custom farm.
 
 * For the [log parser][]:
   * Fixed parse error for logs with zero installed mods.
@@ -17,6 +18,7 @@
   * Fixed input events not recognising controller input as an action or use-tool button.
   * Fixed input events setting the same `IsActionButton` and `IsUseToolButton` values for all buttons pressed in an update tick.
   * Fixed semantic versions always ignoring `-0` tag.
+  * Updated Json.NET to 11.0.1-beta3 (needed to avoid parser edge case with the new converters).
 
 * For SMAPI developers:
   * Overhauled input handling to support future input events.
-- 
cgit 


From d76476ca687a4936cc610380e2b3902db137bced Mon Sep 17 00:00:00 2001
From: Jesse Plamondon-Willard <github@jplamondonw.com>
Date: Sun, 21 Jan 2018 02:14:28 -0500
Subject: add before/after save creation events (#429)

This supports mods like Custom Farm Types that need to intercept the very first save, which doesn't raise the normal save events since the world isn't fully initialised yet.
---
 docs/release-notes.md          |  1 +
 src/SMAPI/Events/SaveEvents.cs | 22 +++++++++++++++++++++-
 src/SMAPI/Framework/SGame.cs   | 18 ++++++++++++++++++
 3 files changed, 40 insertions(+), 1 deletion(-)

(limited to 'docs')

diff --git a/docs/release-notes.md b/docs/release-notes.md
index 38fb680b..afd89c68 100644
--- a/docs/release-notes.md
+++ b/docs/release-notes.md
@@ -12,6 +12,7 @@
   * Fixed parse error for logs with zero installed mods.
 
 * For modders:
+  * Added `SaveEvents.BeforeCreate` and `AfterCreate` events.
   * Added `SButton` `IsActionButton()` and `IsUseToolButton()` extensions.
   * Improved JSON parse errors to provide more useful info for troubleshooting.
   * Fixed events being raised while the game is loading a save file.
diff --git a/src/SMAPI/Events/SaveEvents.cs b/src/SMAPI/Events/SaveEvents.cs
index 50e6d729..99b6c8d2 100644
--- a/src/SMAPI/Events/SaveEvents.cs
+++ b/src/SMAPI/Events/SaveEvents.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using StardewModdingAPI.Framework;
 
 namespace StardewModdingAPI.Events
@@ -9,6 +9,12 @@ namespace StardewModdingAPI.Events
         /*********
         ** Events
         *********/
+        /// <summary>Raised before the game creates the save file.</summary>
+        public static event EventHandler BeforeCreate;
+
+        /// <summary>Raised after the game finishes creating the save file.</summary>
+        public static event EventHandler AfterCreate;
+
         /// <summary>Raised before the game begins writes data to the save file.</summary>
         public static event EventHandler BeforeSave;
 
@@ -25,6 +31,20 @@ namespace StardewModdingAPI.Events
         /*********
         ** Internal methods
         *********/
+        /// <summary>Raise a <see cref="BeforeCreate"/> event.</summary>
+        /// <param name="monitor">Encapsulates monitoring and logging.</param>
+        internal static void InvokeBeforeCreate(IMonitor monitor)
+        {
+            monitor.SafelyRaisePlainEvent($"{nameof(SaveEvents)}.{nameof(SaveEvents.BeforeCreate)}", SaveEvents.BeforeCreate?.GetInvocationList(), null, EventArgs.Empty);
+        }
+
+        /// <summary>Raise a <see cref="AfterCreate"/> event.</summary>
+        /// <param name="monitor">Encapsulates monitoring and logging.</param>
+        internal static void InvokeAfterCreated(IMonitor monitor)
+        {
+            monitor.SafelyRaisePlainEvent($"{nameof(SaveEvents)}.{nameof(SaveEvents.AfterCreate)}", SaveEvents.AfterCreate?.GetInvocationList(), null, EventArgs.Empty);
+        }
+
         /// <summary>Raise a <see cref="BeforeSave"/> event.</summary>
         /// <param name="monitor">Encapsulates monitoring and logging.</param>
         internal static void InvokeBeforeSave(IMonitor monitor)
diff --git a/src/SMAPI/Framework/SGame.cs b/src/SMAPI/Framework/SGame.cs
index 2eb2da99..e82ee778 100644
--- a/src/SMAPI/Framework/SGame.cs
+++ b/src/SMAPI/Framework/SGame.cs
@@ -51,6 +51,9 @@ namespace StardewModdingAPI.Framework
         /// <summary>Whether the game is saving and SMAPI has already raised <see cref="SaveEvents.BeforeSave"/>.</summary>
         private bool IsBetweenSaveEvents;
 
+        /// <summary>Whether the game is creating the save file and SMAPI has already raised <see cref="SaveEvents.BeforeCreate"/>.</summary>
+        private bool IsBetweenCreateEvents;
+
         /****
         ** Game state
         ****/
@@ -246,6 +249,14 @@ namespace StardewModdingAPI.Framework
                 // opened (since the save hasn't started yet), but all other events should be suppressed.
                 if (Context.IsSaving)
                 {
+                    // raise before-create
+                    if (!Context.IsWorldReady && !this.IsBetweenCreateEvents)
+                    {
+                        this.IsBetweenCreateEvents = true;
+                        this.Monitor.Log("Context: before save creation.", LogLevel.Trace);
+                        SaveEvents.InvokeBeforeCreate(this.Monitor);
+                    }
+                    
                     // raise before-save
                     if (Context.IsWorldReady && !this.IsBetweenSaveEvents)
                     {
@@ -258,6 +269,13 @@ namespace StardewModdingAPI.Framework
                     base.Update(gameTime);
                     return;
                 }
+                if (this.IsBetweenCreateEvents)
+                {
+                    // raise after-create
+                    this.IsBetweenCreateEvents = false;
+                    this.Monitor.Log($"Context: after save creation, starting {Game1.currentSeason} {Game1.dayOfMonth} Y{Game1.year}.", LogLevel.Trace);
+                    SaveEvents.InvokeAfterCreated(this.Monitor);
+                }
                 if (this.IsBetweenSaveEvents)
                 {
                     // raise after-save
-- 
cgit 


From 274139eafef34866f8e7d404a52db85c8d89a624 Mon Sep 17 00:00:00 2001
From: Jesse Plamondon-Willard <github@jplamondonw.com>
Date: Sun, 21 Jan 2018 11:48:12 -0500
Subject: rm release note about Custom Farm Types (needs a separate update
 anyway)

---
 docs/release-notes.md | 1 -
 1 file changed, 1 deletion(-)

(limited to 'docs')

diff --git a/docs/release-notes.md b/docs/release-notes.md
index afd89c68..51ac8c5a 100644
--- a/docs/release-notes.md
+++ b/docs/release-notes.md
@@ -6,7 +6,6 @@
   * Fixed error parsing JSON files generated on another platform.
   * Fixed error parsing some JSON files after mods reload core assemblies, which is no longer allowed.
   * Fixed error on Linux loading SMAPI when the default terminal is set to Terminator.
-  * Fixed issue where Custom Farm Types couldn't initialise a custom farm.
 
 * For the [log parser][]:
   * Fixed parse error for logs with zero installed mods.
-- 
cgit 


From 5c96a10da5801049ee17ffa185dbf19e6d8a2306 Mon Sep 17 00:00:00 2001
From: Jesse Plamondon-Willard <github@jplamondonw.com>
Date: Sun, 21 Jan 2018 22:22:44 -0500
Subject: update for release

---
 build/GlobalAssemblyInfo.cs                  |  4 ++--
 docs/release-notes.md                        | 15 ++++++++-------
 src/SMAPI.Mods.ConsoleCommands/manifest.json |  7 +------
 src/SMAPI/Constants.cs                       |  2 +-
 4 files changed, 12 insertions(+), 16 deletions(-)

(limited to 'docs')

diff --git a/build/GlobalAssemblyInfo.cs b/build/GlobalAssemblyInfo.cs
index bcfdc124..79d473e6 100644
--- a/build/GlobalAssemblyInfo.cs
+++ b/build/GlobalAssemblyInfo.cs
@@ -2,5 +2,5 @@ using System.Reflection;
 using System.Runtime.InteropServices;
 
 [assembly: ComVisible(false)]
-[assembly: AssemblyVersion("2.3.0.0")]
-[assembly: AssemblyFileVersion("2.3.0.0")]
+[assembly: AssemblyVersion("2.4.0.0")]
+[assembly: AssemblyFileVersion("2.4.0.0")]
diff --git a/docs/release-notes.md b/docs/release-notes.md
index 51ac8c5a..9c1fbf93 100644
--- a/docs/release-notes.md
+++ b/docs/release-notes.md
@@ -1,14 +1,15 @@
 # Release notes
 ## 2.4
 * For players:
-  * Fixed graphical corruption in rare cases.
-  * Fixed error parsing `config.json` files containing curly quotes.
-  * Fixed error parsing JSON files generated on another platform.
+  * Fixed visual map glitch in rare cases.
+  * Fixed error parsing JSON files which have curly quotes.
+  * Fixed error parsing some JSON files generated on another system.
   * Fixed error parsing some JSON files after mods reload core assemblies, which is no longer allowed.
-  * Fixed error on Linux loading SMAPI when the default terminal is set to Terminator.
+  * Fixed intermittent errors (e.g. 'collection has been modified') with some mods when loading a save.
+  * Fixed compatibility with Linux Terminator terminal.
 
 * For the [log parser][]:
-  * Fixed parse error for logs with zero installed mods.
+  * Fixed error parsing logs with zero installed mods.
 
 * For modders:
   * Added `SaveEvents.BeforeCreate` and `AfterCreate` events.
@@ -17,8 +18,8 @@
   * Fixed events being raised while the game is loading a save file.
   * Fixed input events not recognising controller input as an action or use-tool button.
   * Fixed input events setting the same `IsActionButton` and `IsUseToolButton` values for all buttons pressed in an update tick.
-  * Fixed semantic versions always ignoring `-0` tag.
-  * Updated Json.NET to 11.0.1-beta3 (needed to avoid parser edge case with the new converters).
+  * Fixed semantic versions ignoring `-0` as a prerelease tag.
+  * Updated Json.NET to 11.0.1-beta3 (needed to avoid a parser edge case).
 
 * For SMAPI developers:
   * Overhauled input handling to support future input events.
diff --git a/src/SMAPI.Mods.ConsoleCommands/manifest.json b/src/SMAPI.Mods.ConsoleCommands/manifest.json
index 06ab1b54..fc5ce35d 100644
--- a/src/SMAPI.Mods.ConsoleCommands/manifest.json
+++ b/src/SMAPI.Mods.ConsoleCommands/manifest.json
@@ -1,12 +1,7 @@
 {
   "Name": "Console Commands",
   "Author": "SMAPI",
-  "Version": {
-    "MajorVersion": 2,
-    "MinorVersion": 3,
-    "PatchVersion": 0,
-    "Build": null
-  },
+  "Version": "2.4.0",
   "Description": "Adds SMAPI console commands that let you manipulate the game.",
   "UniqueID": "SMAPI.ConsoleCommands",
   "EntryDll": "ConsoleCommands.dll"
diff --git a/src/SMAPI/Constants.cs b/src/SMAPI/Constants.cs
index 786ae32b..515e9870 100644
--- a/src/SMAPI/Constants.cs
+++ b/src/SMAPI/Constants.cs
@@ -29,7 +29,7 @@ namespace StardewModdingAPI
         ** Public
         ****/
         /// <summary>SMAPI's current semantic version.</summary>
-        public static ISemanticVersion ApiVersion { get; } = new SemanticVersion("2.3");
+        public static ISemanticVersion ApiVersion { get; } = new SemanticVersion("2.4.0");
 
         /// <summary>The minimum supported version of Stardew Valley.</summary>
         public static ISemanticVersion MinimumGameVersion { get; } = new SemanticVersion("1.2.30");
-- 
cgit