Merge branch 'develop' into stable

7 files changed, 542 insertions, 0 deletions

diff --git a/src/SMAPI/Framework/StateTracking/FieldWatchers/BaseDisposableWatcher.cs b/src/SMAPI/Framework/StateTracking/FieldWatchers/BaseDisposableWatcher.cs
new file mode 100644
index 00000000..40ec6c57
--- /dev/null
+++ b/src/SMAPI/Framework/StateTracking/FieldWatchers/BaseDisposableWatcher.cs
@@ -0,0 +1,36 @@
+using System;
+
+namespace StardewModdingAPI.Framework.StateTracking.FieldWatchers
+{
+    /// <summary>The base implementation for a disposable watcher.</summary>
+    internal abstract class BaseDisposableWatcher : IDisposable
+    {
+        /*********
+        ** Properties
+        *********/
+        /// <summary>Whether the watcher has been disposed.</summary>
+        protected bool IsDisposed { get; private set; }
+
+
+        /*********
+        ** Public methods
+        *********/
+        /// <summary>Stop watching the field and release all references.</summary>
+        public virtual void Dispose()
+        {
+            this.IsDisposed = true;
+        }
+
+
+        /*********
+        ** Protected methods
+        *********/
+        /// <summary>Throw an exception if the watcher is disposed.</summary>
+        /// <exception cref="ObjectDisposedException">The watcher is disposed.</exception>
+        protected void AssertNotDisposed()
+        {
+            if (this.IsDisposed)
+                throw new ObjectDisposedException(this.GetType().Name);
+        }
+    }
+}
diff --git a/src/SMAPI/Framework/StateTracking/FieldWatchers/ComparableWatcher.cs b/src/SMAPI/Framework/StateTracking/FieldWatchers/ComparableWatcher.cs
new file mode 100644
index 00000000..d51fc2ac
--- /dev/null
+++ b/src/SMAPI/Framework/StateTracking/FieldWatchers/ComparableWatcher.cs
@@ -0,0 +1,62 @@
+using System;
+using System.Collections.Generic;
+
+namespace StardewModdingAPI.Framework.StateTracking.FieldWatchers
+{
+    /// <summary>A watcher which detects changes to a value using a specified <see cref="IEqualityComparer{T}"/> instance.</summary>
+    internal class ComparableWatcher<T> : IValueWatcher<T>
+    {
+        /*********
+        ** Properties
+        *********/
+        /// <summary>Get the current value.</summary>
+        private readonly Func<T> GetValue;
+
+        /// <summary>The equality comparer.</summary>
+        private readonly IEqualityComparer<T> Comparer;
+
+
+        /*********
+        ** Accessors
+        *********/
+        /// <summary>The field value at the last reset.</summary>
+        public T PreviousValue { get; private set; }
+
+        /// <summary>The latest value.</summary>
+        public T CurrentValue { get; private set; }
+
+        /// <summary>Whether the value changed since the last reset.</summary>
+        public bool IsChanged { get; private set; }
+
+
+        /*********
+        ** Public methods
+        *********/
+        /// <summary>Construct an instance.</summary>
+        /// <param name="getValue">Get the current value.</param>
+        /// <param name="comparer">The equality comparer which indicates whether two values are the same.</param>
+        public ComparableWatcher(Func<T> getValue, IEqualityComparer<T> comparer)
+        {
+            this.GetValue = getValue;
+            this.Comparer = comparer;
+            this.PreviousValue = getValue();
+        }
+
+        /// <summary>Update the current value if needed.</summary>
+        public void Update()
+        {
+            this.CurrentValue = this.GetValue();
+            this.IsChanged = !this.Comparer.Equals(this.PreviousValue, this.CurrentValue);
+        }
+
+        /// <summary>Set the current value as the baseline.</summary>
+        public void Reset()
+        {
+            this.PreviousValue = this.CurrentValue;
+            this.IsChanged = false;
+        }
+
+        /// <summary>Release any references if needed when the field is no longer needed.</summary>
+        public void Dispose() { }
+    }
+}
diff --git a/src/SMAPI/Framework/StateTracking/FieldWatchers/NetCollectionWatcher.cs b/src/SMAPI/Framework/StateTracking/FieldWatchers/NetCollectionWatcher.cs
new file mode 100644
index 00000000..f92edb90
--- /dev/null
+++ b/src/SMAPI/Framework/StateTracking/FieldWatchers/NetCollectionWatcher.cs
@@ -0,0 +1,93 @@
+using System.Collections.Generic;
+using Netcode;
+
+namespace StardewModdingAPI.Framework.StateTracking.FieldWatchers
+{
+    /// <summary>A watcher which detects changes to a Netcode collection.</summary>
+    internal class NetCollectionWatcher<TValue> : BaseDisposableWatcher, ICollectionWatcher<TValue>
+        where TValue : INetObject<INetSerializable>
+    {
+        /*********
+        ** Properties
+        *********/
+        /// <summary>The field being watched.</summary>
+        private readonly NetCollection<TValue> Field;
+
+        /// <summary>The pairs added since the last reset.</summary>
+        private readonly List<TValue> AddedImpl = new List<TValue>();
+
+        /// <summary>The pairs demoved since the last reset.</summary>
+        private readonly List<TValue> RemovedImpl = new List<TValue>();
+
+
+        /*********
+        ** Accessors
+        *********/
+        /// <summary>Whether the collection changed since the last reset.</summary>
+        public bool IsChanged => this.AddedImpl.Count > 0 || this.RemovedImpl.Count > 0;
+
+        /// <summary>The values added since the last reset.</summary>
+        public IEnumerable<TValue> Added => this.AddedImpl;
+
+        /// <summary>The values removed since the last reset.</summary>
+        public IEnumerable<TValue> Removed => this.RemovedImpl;
+
+
+        /*********
+        ** Public methods
+        *********/
+        /// <summary>Construct an instance.</summary>
+        /// <param name="field">The field to watch.</param>
+        public NetCollectionWatcher(NetCollection<TValue> field)
+        {
+            this.Field = field;
+            field.OnValueAdded += this.OnValueAdded;
+            field.OnValueRemoved += this.OnValueRemoved;
+        }
+
+        /// <summary>Update the current value if needed.</summary>
+        public void Update()
+        {
+            this.AssertNotDisposed();
+        }
+
+        /// <summary>Set the current value as the baseline.</summary>
+        public void Reset()
+        {
+            this.AssertNotDisposed();
+
+            this.AddedImpl.Clear();
+            this.RemovedImpl.Clear();
+        }
+
+        /// <summary>Stop watching the field and release all references.</summary>
+        public override void Dispose()
+        {
+            if (!this.IsDisposed)
+            {
+                this.Field.OnValueAdded -= this.OnValueAdded;
+                this.Field.OnValueRemoved -= this.OnValueRemoved;
+            }
+
+            base.Dispose();
+        }
+
+
+        /*********
+        ** Private methods
+        *********/
+        /// <summary>A callback invoked when an entry is added to the collection.</summary>
+        /// <param name="value">The added value.</param>
+        private void OnValueAdded(TValue value)
+        {
+            this.AddedImpl.Add(value);
+        }
+
+        /// <summary>A callback invoked when an entry is removed from the collection.</summary>
+        /// <param name="value">The added value.</param>
+        private void OnValueRemoved(TValue value)
+        {
+            this.RemovedImpl.Add(value);
+        }
+    }
+}
diff --git a/src/SMAPI/Framework/StateTracking/FieldWatchers/NetDictionaryWatcher.cs b/src/SMAPI/Framework/StateTracking/FieldWatchers/NetDictionaryWatcher.cs
new file mode 100644
index 00000000..7a2bf84e
--- /dev/null
+++ b/src/SMAPI/Framework/StateTracking/FieldWatchers/NetDictionaryWatcher.cs
@@ -0,0 +1,103 @@
+using System.Collections.Generic;
+using Netcode;
+
+namespace StardewModdingAPI.Framework.StateTracking.FieldWatchers
+{
+    /// <summary>A watcher which detects changes to a net dictionary field.</summary>
+    /// <typeparam name="TKey">The dictionary key type.</typeparam>
+    /// <typeparam name="TValue">The dictionary value type.</typeparam>
+    /// <typeparam name="TField">The net type equivalent to <typeparamref name="TValue"/>.</typeparam>
+    /// <typeparam name="TSerialDict">The serializable dictionary type that can store the keys and values.</typeparam>
+    /// <typeparam name="TSelf">The net field instance type.</typeparam>
+    internal class NetDictionaryWatcher<TKey, TValue, TField, TSerialDict, TSelf> : BaseDisposableWatcher, IDictionaryWatcher<TKey, TValue>
+        where TField : class, INetObject<INetSerializable>, new()
+        where TSerialDict : IDictionary<TKey, TValue>, new()
+        where TSelf : NetDictionary<TKey, TValue, TField, TSerialDict, TSelf>
+    {
+        /*********
+        ** Properties
+        *********/
+        /// <summary>The pairs added since the last reset.</summary>
+        private readonly IDictionary<TKey, TValue> PairsAdded = new Dictionary<TKey, TValue>();
+
+        /// <summary>The pairs demoved since the last reset.</summary>
+        private readonly IDictionary<TKey, TValue> PairsRemoved = new Dictionary<TKey, TValue>();
+
+        /// <summary>The field being watched.</summary>
+        private readonly NetDictionary<TKey, TValue, TField, TSerialDict, TSelf> Field;
+
+
+        /*********
+        ** Accessors
+        *********/
+        /// <summary>Whether the collection changed since the last reset.</summary>
+        public bool IsChanged => this.PairsAdded.Count > 0 || this.PairsRemoved.Count > 0;
+
+        /// <summary>The values added since the last reset.</summary>
+        public IEnumerable<KeyValuePair<TKey, TValue>> Added => this.PairsAdded;
+
+        /// <summary>The values removed since the last reset.</summary>
+        public IEnumerable<KeyValuePair<TKey, TValue>> Removed => this.PairsRemoved;
+
+
+        /*********
+        ** Public methods
+        *********/
+        /// <summary>Construct an instance.</summary>
+        /// <param name="field">The field to watch.</param>
+        public NetDictionaryWatcher(NetDictionary<TKey, TValue, TField, TSerialDict, TSelf> field)
+        {
+            this.Field = field;
+
+            field.OnValueAdded += this.OnValueAdded;
+            field.OnValueRemoved += this.OnValueRemoved;
+        }
+
+        /// <summary>Update the current value if needed.</summary>
+        public void Update()
+        {
+            this.AssertNotDisposed();
+        }
+
+        /// <summary>Set the current value as the baseline.</summary>
+        public void Reset()
+        {
+            this.AssertNotDisposed();
+
+            this.PairsAdded.Clear();
+            this.PairsRemoved.Clear();
+        }
+
+        /// <summary>Stop watching the field and release all references.</summary>
+        public override void Dispose()
+        {
+            if (!this.IsDisposed)
+            {
+                this.Field.OnValueAdded -= this.OnValueAdded;
+                this.Field.OnValueRemoved -= this.OnValueRemoved;
+            }
+            base.Dispose();
+        }
+
+
+        /*********
+        ** Private methods
+        *********/
+        /// <summary>A callback invoked when an entry is added to the dictionary.</summary>
+        /// <param name="key">The entry key.</param>
+        /// <param name="value">The entry value.</param>
+        private void OnValueAdded(TKey key, TValue value)
+        {
+            this.PairsAdded[key] = value;
+        }
+
+        /// <summary>A callback invoked when an entry is removed from the dictionary.</summary>
+        /// <param name="key">The entry key.</param>
+        /// <param name="value">The entry value.</param>
+        private void OnValueRemoved(TKey key, TValue value)
+        {
+            if (!this.PairsRemoved.ContainsKey(key))
+                this.PairsRemoved[key] = value;
+        }
+    }
+}
diff --git a/src/SMAPI/Framework/StateTracking/FieldWatchers/NetValueWatcher.cs b/src/SMAPI/Framework/StateTracking/FieldWatchers/NetValueWatcher.cs
new file mode 100644
index 00000000..188ed9f3
--- /dev/null
+++ b/src/SMAPI/Framework/StateTracking/FieldWatchers/NetValueWatcher.cs
@@ -0,0 +1,83 @@
+using Netcode;
+
+namespace StardewModdingAPI.Framework.StateTracking.FieldWatchers
+{
+    /// <summary>A watcher which detects changes to a net value field.</summary>
+    internal class NetValueWatcher<T, TSelf> : BaseDisposableWatcher, IValueWatcher<T> where TSelf : NetFieldBase<T, TSelf>
+    {
+        /*********
+        ** Properties
+        *********/
+        /// <summary>The field being watched.</summary>
+        private readonly NetFieldBase<T, TSelf> Field;
+
+
+        /*********
+        ** Accessors
+        *********/
+        /// <summary>Whether the value changed since the last reset.</summary>
+        public bool IsChanged { get; private set; }
+
+        /// <summary>The field value at the last reset.</summary>
+        public T PreviousValue { get; private set; }
+
+        /// <summary>The latest value.</summary>
+        public T CurrentValue { get; private set; }
+
+
+        /*********
+        ** Public methods
+        *********/
+        /// <summary>Construct an instance.</summary>
+        /// <param name="field">The field to watch.</param>
+        public NetValueWatcher(NetFieldBase<T, TSelf> field)
+        {
+            this.Field = field;
+            this.PreviousValue = field.Value;
+            this.CurrentValue = field.Value;
+
+            field.fieldChangeVisibleEvent += this.OnValueChanged;
+            field.fieldChangeEvent += this.OnValueChanged;
+        }
+
+        /// <summary>Update the current value if needed.</summary>
+        public void Update()
+        {
+            this.AssertNotDisposed();
+        }
+
+        /// <summary>Set the current value as the baseline.</summary>
+        public void Reset()
+        {
+            this.AssertNotDisposed();
+
+            this.PreviousValue = this.CurrentValue;
+            this.IsChanged = false;
+        }
+
+        /// <summary>Stop watching the field and release all references.</summary>
+        public override void Dispose()
+        {
+            if (!this.IsDisposed)
+            {
+                this.Field.fieldChangeEvent -= this.OnValueChanged;
+                this.Field.fieldChangeVisibleEvent -= this.OnValueChanged;
+            }
+            base.Dispose();
+        }
+
+
+        /*********
+        ** Private methods
+        *********/
+        /// <summary>A callback invoked when the field's value changes.</summary>
+        /// <param name="field">The field being watched.</param>
+        /// <param name="oldValue">The old field value.</param>
+        /// <param name="newValue">The new field value.</param>
+        private void OnValueChanged(TSelf field, T oldValue, T newValue)
+        {
+            this.CurrentValue = newValue;
+            this.IsChanged = true;
+        }
+    }
+}
diff --git a/src/SMAPI/Framework/StateTracking/FieldWatchers/ObservableCollectionWatcher.cs b/src/SMAPI/Framework/StateTracking/FieldWatchers/ObservableCollectionWatcher.cs
new file mode 100644
index 00000000..34a97097
--- /dev/null
+++ b/src/SMAPI/Framework/StateTracking/FieldWatchers/ObservableCollectionWatcher.cs
@@ -0,0 +1,86 @@
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.Linq;
+
+namespace StardewModdingAPI.Framework.StateTracking.FieldWatchers
+{
+    /// <summary>A watcher which detects changes to an observable collection.</summary>
+    internal class ObservableCollectionWatcher<TValue> : BaseDisposableWatcher, ICollectionWatcher<TValue>
+    {
+        /*********
+        ** Properties
+        *********/
+        /// <summary>The field being watched.</summary>
+        private readonly ObservableCollection<TValue> Field;
+
+        /// <summary>The pairs added since the last reset.</summary>
+        private readonly List<TValue> AddedImpl = new List<TValue>();
+
+        /// <summary>The pairs demoved since the last reset.</summary>
+        private readonly List<TValue> RemovedImpl = new List<TValue>();
+
+
+        /*********
+        ** Accessors
+        *********/
+        /// <summary>Whether the collection changed since the last reset.</summary>
+        public bool IsChanged => this.AddedImpl.Count > 0 || this.RemovedImpl.Count > 0;
+
+        /// <summary>The values added since the last reset.</summary>
+        public IEnumerable<TValue> Added => this.AddedImpl;
+
+        /// <summary>The values removed since the last reset.</summary>
+        public IEnumerable<TValue> Removed => this.RemovedImpl;
+
+
+        /*********
+        ** Public methods
+        *********/
+        /// <summary>Construct an instance.</summary>
+        /// <param name="field">The field to watch.</param>
+        public ObservableCollectionWatcher(ObservableCollection<TValue> field)
+        {
+            this.Field = field;
+            field.CollectionChanged += this.OnCollectionChanged;
+        }
+
+        /// <summary>Update the current value if needed.</summary>
+        public void Update()
+        {
+            this.AssertNotDisposed();
+        }
+
+        /// <summary>Set the current value as the baseline.</summary>
+        public void Reset()
+        {
+            this.AssertNotDisposed();
+
+            this.AddedImpl.Clear();
+            this.RemovedImpl.Clear();
+        }
+
+        /// <summary>Stop watching the field and release all references.</summary>
+        public override void Dispose()
+        {
+            if (!this.IsDisposed)
+                this.Field.CollectionChanged -= this.OnCollectionChanged;
+            base.Dispose();
+        }
+
+
+        /*********
+        ** Private methods
+        *********/
+        /// <summary>A callback invoked when an entry is added or removed from the collection.</summary>
+        /// <param name="sender">The event sender.</param>
+        /// <param name="e">The event arguments.</param>
+        private void OnCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
+        {
+            if (e.NewItems != null)
+                this.AddedImpl.AddRange(e.NewItems.Cast<TValue>());
+            if (e.OldItems != null)
+                this.RemovedImpl.AddRange(e.OldItems.Cast<TValue>());
+        }
+    }
+}
diff --git a/src/SMAPI/Framework/StateTracking/FieldWatchers/WatcherFactory.cs b/src/SMAPI/Framework/StateTracking/FieldWatchers/WatcherFactory.cs
new file mode 100644
index 00000000..d7a02668
--- /dev/null
+++ b/src/SMAPI/Framework/StateTracking/FieldWatchers/WatcherFactory.cs
@@ -0,0 +1,79 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using Netcode;
+using StardewModdingAPI.Framework.StateTracking.Comparers;
+
+namespace StardewModdingAPI.Framework.StateTracking.FieldWatchers
+{
+    /// <summary>Provides convenience wrappers for creating watchers.</summary>
+    internal static class WatcherFactory
+    {
+        /*********
+        ** Public methods
+        *********/
+        /// <summary>Get a watcher which compares values using their <see cref="object.Equals(object)"/> method. This method should only be used when <see cref="ForEquatable{T}"/> won't work, since this doesn't validate whether they're comparable.</summary>
+        /// <typeparam name="T">The value type.</typeparam>
+        /// <param name="getValue">Get the current value.</param>
+        public static ComparableWatcher<T> ForGenericEquality<T>(Func<T> getValue) where T : struct
+        {
+            return new ComparableWatcher<T>(getValue, new GenericEqualsComparer<T>());
+        }
+
+        /// <summary>Get a watcher for an <see cref="IEquatable{T}"/> value.</summary>
+        /// <typeparam name="T">The value type.</typeparam>
+        /// <param name="getValue">Get the current value.</param>
+        public static ComparableWatcher<T> ForEquatable<T>(Func<T> getValue) where T : IEquatable<T>
+        {
+            return new ComparableWatcher<T>(getValue, new EquatableComparer<T>());
+        }
+
+        /// <summary>Get a watcher which detects when an object reference changes.</summary>
+        /// <typeparam name="T">The value type.</typeparam>
+        /// <param name="getValue">Get the current value.</param>
+        public static ComparableWatcher<T> ForReference<T>(Func<T> getValue)
+        {
+            return new ComparableWatcher<T>(getValue, new ObjectReferenceComparer<T>());
+        }
+
+        /// <summary>Get a watcher for an observable collection.</summary>
+        /// <typeparam name="T">The value type.</typeparam>
+        /// <param name="collection">The observable collection.</param>
+        public static ObservableCollectionWatcher<T> ForObservableCollection<T>(ObservableCollection<T> collection)
+        {
+            return new ObservableCollectionWatcher<T>(collection);
+        }
+
+        /// <summary>Get a watcher for a net collection.</summary>
+        /// <typeparam name="T">The value type.</typeparam>
+        /// <typeparam name="TSelf">The net field instance type.</typeparam>
+        /// <param name="field">The net collection.</param>
+        public static NetValueWatcher<T, TSelf> ForNetValue<T, TSelf>(NetFieldBase<T, TSelf> field) where TSelf : NetFieldBase<T, TSelf>
+        {
+            return new NetValueWatcher<T, TSelf>(field);
+        }
+
+        /// <summary>Get a watcher for a net collection.</summary>
+        /// <typeparam name="T">The value type.</typeparam>
+        /// <param name="collection">The net collection.</param>
+        public static NetCollectionWatcher<T> ForNetCollection<T>(NetCollection<T> collection) where T : INetObject<INetSerializable>
+        {
+            return new NetCollectionWatcher<T>(collection);
+        }
+
+        /// <summary>Get a watcher for a net dictionary.</summary>
+        /// <typeparam name="TKey">The dictionary key type.</typeparam>
+        /// <typeparam name="TValue">The dictionary value type.</typeparam>
+        /// <typeparam name="TField">The net type equivalent to <typeparamref name="TValue"/>.</typeparam>
+        /// <typeparam name="TSerialDict">The serializable dictionary type that can store the keys and values.</typeparam>
+        /// <typeparam name="TSelf">The net field instance type.</typeparam>
+        /// <param name="field">The net field.</param>
+        public static NetDictionaryWatcher<TKey, TValue, TField, TSerialDict, TSelf> ForNetDictionary<TKey, TValue, TField, TSerialDict, TSelf>(NetDictionary<TKey, TValue, TField, TSerialDict, TSelf> field)
+            where TField : class, INetObject<INetSerializable>, new()
+            where TSerialDict : IDictionary<TKey, TValue>, new()
+            where TSelf : NetDictionary<TKey, TValue, TField, TSerialDict, TSelf>
+        {
+            return new NetDictionaryWatcher<TKey, TValue, TField, TSerialDict, TSelf>(field);
+        }
+    }
+}