fishnet installed

Assets/FishNet/Runtime/Editor/Configuring/ConfigurationData.cs

@@ -0,0 +1,146 @@
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Xml.Serialization;
+
+#if UNITY_EDITOR
+using UnityEditor;
+#endif
+
+namespace FishNet.Configuring
+{
+
+    public enum StrippingTypes : int
+    {
+        Redirect = 0,
+        Empty_Experimental = 1,
+    }
+    public enum SearchScopeType : int
+    {
+        EntireProject = 0,
+        SpecificFolders = 1,
+    }
+
+    public class PrefabGeneratorConfigurations
+    {
+        public bool Enabled = true;
+        public bool LogToConsole = true;
+        public bool FullRebuild = false;
+        public bool SaveChanges = true;
+        public string DefaultPrefabObjectsPath = Path.Combine("Assets", "DefaultPrefabObjects.asset");
+        public int SearchScope = (int)SearchScopeType.EntireProject;
+        public List<string> ExcludedFolders = new List<string>();
+        public List<string> IncludedFolders = new List<string>();
+    }
+
+    public class CodeStrippingConfigurations
+    {
+        public bool IsBuilding = false;
+        public bool IsDevelopment = false;
+        public bool IsHeadless = false;
+        public bool StripReleaseBuilds = false;
+        public int StrippingType = (int)StrippingTypes.Redirect;
+    }
+
+
+    public class ConfigurationData
+    {
+        //Non serialized doesn't really do anything, its just for me.
+        [System.NonSerialized]
+        public bool Loaded;
+
+        public PrefabGeneratorConfigurations PrefabGenerator = new PrefabGeneratorConfigurations();
+        public CodeStrippingConfigurations CodeStripping = new CodeStrippingConfigurations();
+    }
+
+    public static class ConfigurationDataExtension
+    {
+        /// <summary>
+        /// Returns if a differs from b.
+        /// </summary>
+        public static bool HasChanged(this ConfigurationData a, ConfigurationData b)
+        {
+            return (a.CodeStripping.StripReleaseBuilds != b.CodeStripping.StripReleaseBuilds);
+        }
+        /// <summary>
+        /// Copies all values from source to target.
+        /// </summary>
+        public static void CopyTo(this ConfigurationData source, ConfigurationData target)
+        {
+            target.CodeStripping.StripReleaseBuilds = source.CodeStripping.StripReleaseBuilds;
+        }
+
+
+        /// <summary>
+        /// Writes a configuration data.
+        /// </summary>
+        public static void Write(this ConfigurationData cd, bool refreshAssetDatabase)
+        {
+            /* Why is this a thing you ask? Because Unity makes it VERY difficult to read values from
+             * memory during builds since on some Unity versions the building application is on a different
+             * processor. In result instead of using memory to read configurationdata the values
+             * must be written to disk then load the disk values as needed.
+             * 
+             * Fortunatelly the file is extremely small and this does not occur often at all. The disk read
+             * will occur once per script save, and once per assembly when building. */
+            try
+            {
+                string path = Configuration.GetAssetsPath(Configuration.CONFIG_FILE_NAME);
+                XmlSerializer serializer = new XmlSerializer(typeof(ConfigurationData));
+                TextWriter writer = new StreamWriter(path);
+                serializer.Serialize(writer, cd);
+                writer.Close();
+#if UNITY_EDITOR
+                if (refreshAssetDatabase)
+                {
+                    AssetDatabase.SaveAssets();
+                    AssetDatabase.Refresh();
+                }
+#endif
+            }
+            catch (Exception ex)
+            {
+                throw new Exception($"An error occurred while writing ConfigurationData. Message: {ex.Message}");
+            }
+
+        }
+
+
+        /// <summary>
+        /// Writes a configuration data.
+        /// </summary>
+        public static void Write(this ConfigurationData cd, string path, bool refreshAssetDatabase)
+        {
+            /* Why is this a thing you ask? Because Unity makes it VERY difficult to read values from
+             * memory during builds since on some Unity versions the building application is on a different
+             * processor. In result instead of using memory to read configurationdata the values
+             * must be written to disk then load the disk values as needed.
+             * 
+             * Fortunatelly the file is extremely small and this does not occur often at all. The disk read
+             * will occur once per script save, and once per assembly when building. */
+            try
+            {
+                XmlSerializer serializer = new XmlSerializer(typeof(ConfigurationData));
+                TextWriter writer = new StreamWriter(path);
+                serializer.Serialize(writer, cd);
+                writer.Close();
+#if UNITY_EDITOR
+                if (refreshAssetDatabase)
+                {
+                    AssetDatabase.SaveAssets();
+                    AssetDatabase.Refresh();
+                }
+#endif
+            }
+            catch (Exception ex)
+            {
+                throw new Exception($"An error occurred while writing ConfigurationData. Message: {ex.Message}");
+            }
+
+        }
+
+    }
+
+
+}

Assets/FishNet/Runtime/Editor/Configuring/ConfigurationData.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 4be37e1b0afd29944ad4fa0b92ed8c7e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/FishNet/Runtime/Editor/Configuring/ConfigurationEditor.cs

@@ -0,0 +1,126 @@
+#if UNITY_EDITOR
+using FishNet.Editing.PrefabCollectionGenerator;
+using FishNet.Object;
+using FishNet.Utility.Extension;
+using FishNet.Utility.Performance;
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.SceneManagement;
+
+namespace FishNet.Editing
+{
+    public class ConfigurationEditor : EditorWindow
+    {
+
+        [MenuItem("Fish-Networking/Configuration", false, 0)]
+        public static void ShowConfiguration()
+        {
+            SettingsService.OpenProjectSettings("Project/Fish-Networking/Configuration");
+        }
+
+    }
+
+    public class RebuildSceneIdMenu : MonoBehaviour
+    {
+        /// <summary>
+        /// Rebuilds sceneIds for open scenes.
+        /// </summary>
+        [MenuItem("Fish-Networking/Rebuild SceneIds", false, 20)]
+        public static void RebuildSceneIds()
+        {
+            int generatedCount = 0;
+            for (int i = 0; i < SceneManager.sceneCount; i++)
+            {
+                Scene s = SceneManager.GetSceneAt(i);
+
+                ListCache<NetworkObject> nobs;
+                SceneFN.GetSceneNetworkObjects(s, false, out nobs);
+                for (int z = 0; z < nobs.Written; z++)
+                {
+                    NetworkObject nob = nobs.Collection[z];
+                    nob.TryCreateSceneID();
+                    EditorUtility.SetDirty(nob);
+                }
+                generatedCount += nobs.Written;
+
+                ListCaches.StoreCache(nobs);
+            }
+
+            Debug.Log($"Generated sceneIds for {generatedCount} objects over {SceneManager.sceneCount} scenes. Please save your open scenes.");
+        }
+
+
+    }
+
+    public class RefreshDefaultPrefabsMenu : MonoBehaviour
+    {
+        /// <summary>
+        /// Rebuilds the DefaultPrefabsCollection file.
+        /// </summary>
+        [MenuItem("Fish-Networking/Refresh Default Prefabs", false, 22)]
+        public static void RebuildDefaultPrefabs()
+        {
+            Debug.Log("Refreshing default prefabs.");
+            Generator.GenerateFull(null, true);
+        }
+
+    }
+
+
+    public class RemoveDuplicateNetworkObjectsMenu : MonoBehaviour
+    {
+        /// <summary>
+        /// Iterates all network object prefabs in the project and open scenes, removing NetworkObject components which exist multiple times on a single object.
+        /// </summary>
+        [MenuItem("Fish-Networking/Remove Duplicate NetworkObjects", false, 21)]
+
+        public static void RemoveDuplicateNetworkObjects()
+        {
+            List<NetworkObject> foundNobs = new List<NetworkObject>();
+
+            foreach (string path in Generator.GetPrefabFiles("Assets", new HashSet<string>(), true))
+            {
+                NetworkObject nob = AssetDatabase.LoadAssetAtPath<NetworkObject>(path);
+                if (nob != null)
+                    foundNobs.Add(nob);
+            }
+
+            //Now add scene objects.
+            for (int i = 0; i < SceneManager.sceneCount; i++)
+            {
+                Scene s = SceneManager.GetSceneAt(i);
+
+                ListCache<NetworkObject> nobs;
+                SceneFN.GetSceneNetworkObjects(s, false, out nobs);
+                for (int z = 0; z < nobs.Written; z++)
+                {
+                    NetworkObject nob = nobs.Collection[z];
+                    nob.TryCreateSceneID();
+                    EditorUtility.SetDirty(nob);
+                }
+                for (int z = 0; z < nobs.Written; z++)
+                    foundNobs.Add(nobs.Collection[i]);
+
+                ListCaches.StoreCache(nobs);
+            }
+
+            //Remove duplicates.
+            int removed = 0;
+            foreach (NetworkObject nob in foundNobs)
+            {
+                int count = nob.RemoveDuplicateNetworkObjects();
+                if (count > 0)
+                    removed += count;
+            }
+
+            Debug.Log($"Removed {removed} duplicate NetworkObjects. Please save your open scenes and project.");
+        }
+
+    }
+
+
+
+
+}
+#endif

Assets/FishNet/Runtime/Editor/Configuring/ConfigurationEditor.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 8135b3a4c31cfb74896f1e9e77059c89
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/FishNet/Runtime/Editor/Configuring/Configuring.cs

@@ -0,0 +1,102 @@
+using System.IO;
+using System.Xml.Serialization;
+using UnityEngine;
+
+#if UNITY_EDITOR
+using UnityEditor.Compilation;
+using UnityEditor.Build.Reporting;
+using UnityEditor;
+using UnityEditor.Build;
+#endif
+
+namespace FishNet.Configuring
+{
+
+
+    public class Configuration
+    {
+
+        /// <summary>
+        /// 
+        /// </summary>
+        private static ConfigurationData _configurations;
+        /// <summary>
+        /// ConfigurationData to use.
+        /// </summary>
+        public static ConfigurationData Configurations
+        {
+            get
+            {
+                if (_configurations == null)
+                    _configurations = LoadConfigurationData();
+                if (_configurations == null)
+                    throw new System.Exception("Fish-Networking Configurations could not be loaded. Certain features such as code-stripping may not function.");
+                return _configurations;
+            }
+            private set
+            {
+                _configurations = value;
+            }
+        }
+
+        /// <summary>
+        /// File name for configuration disk data.
+        /// </summary>
+        public const string CONFIG_FILE_NAME = "FishNet.Config.XML";
+
+        /// <summary>
+        /// Returns the path for the configuration file.
+        /// </summary>
+        /// <returns></returns>
+        internal static string GetAssetsPath(string additional = "")
+        {
+            string a = Path.Combine(System.IO.Directory.GetCurrentDirectory(), "Assets");
+            if (additional != "")
+                a = Path.Combine(a, additional);
+            return a;
+        }
+        /// <summary>
+        /// Returns FishNetworking ConfigurationData.
+        /// </summary>
+        /// <returns></returns>
+        internal static ConfigurationData LoadConfigurationData()
+        {
+            //return new ConfigurationData();
+            if (_configurations == null || !_configurations.Loaded)
+            {
+                string configPath = GetAssetsPath(CONFIG_FILE_NAME);
+                //string configPath = string.Empty;
+                //File is on disk.
+                if (File.Exists(configPath))
+                {
+                    FileStream fs = null;
+                    try
+                    {
+                        XmlSerializer serializer = new XmlSerializer(typeof(ConfigurationData));
+                        fs = new FileStream(configPath, FileMode.Open, FileAccess.Read, FileShare.Read);
+                        _configurations = (ConfigurationData)serializer.Deserialize(fs);
+                    }
+                    finally
+                    {
+                        fs?.Close();
+                    }
+                    _configurations.Loaded = true;
+                }
+                else
+                {
+                    //If null then make a new instance.
+                    if (_configurations == null)
+                        _configurations = new ConfigurationData();
+                    //Don't unset loaded, if its true then it should have proper info.
+                    //_configurationData.Loaded = false;
+                }
+            }
+
+            return _configurations;
+
+        }
+
+    }
+
+
+}

Assets/FishNet/Runtime/Editor/Configuring/Configuring.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 8d05bf07ec9af2c46a1fe6c24871cccb
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/FishNet/Runtime/Editor/Configuring/FIshNetGettingStartedEditor.cs

@@ -0,0 +1,172 @@
+#if UNITY_EDITOR
+using UnityEditor;
+using UnityEngine;
+
+namespace FishNet.Editing
+{
+
+    /// <summary>
+    /// Contributed by YarnCat! Thank you!
+    /// </summary>
+    public class FishNetGettingStartedEditor : EditorWindow
+    {
+        private Texture2D _fishnetLogo, _reviewButtonBg, _reviewButtonBgHover;
+        private GUIStyle _labelStyle, _reviewButtonStyle;
+
+        private const string SHOWED_GETTING_STARTED = "ShowedFishNetGettingStarted";
+
+        [MenuItem("Fish-Networking/Getting Started")]
+        public static void GettingStartedMenu()
+        {
+            FishNetGettingStartedEditor window = (FishNetGettingStartedEditor)EditorWindow.GetWindow(typeof(FishNetGettingStartedEditor));
+            window.position = new Rect(0, 0, 320, 355);
+            Rect mainPos;
+#if UNITY_2020_1_OR_NEWER
+            mainPos = EditorGUIUtility.GetMainWindowPosition();
+#else
+            mainPos = new Rect(Vector2.zero, Vector2.zero);
+#endif
+            var pos = window.position;  
+            float w = (mainPos.width - pos.width) * 0.5f;
+            float h = (mainPos.height - pos.height) * 0.5f;
+            pos.x = mainPos.x + w;
+            pos.y = mainPos.y + h;
+            window.position = pos;
+
+            window._fishnetLogo = (Texture2D)AssetDatabase.LoadAssetAtPath("Assets/FishNet/Runtime/Editor/Textures/UI/Logo_With_Text.png", typeof(Texture));
+            window._labelStyle = new GUIStyle("label");
+            window._labelStyle.fontSize = 24;
+            window._labelStyle.wordWrap = true;   
+            //window.labelStyle.alignment = TextAnchor.MiddleCenter;
+            window._labelStyle.normal.textColor = new Color32(74, 195, 255, 255);
+
+            window._reviewButtonBg = MakeBackgroundTexture(1, 1, new Color32(52, 111, 255, 255));
+            window._reviewButtonBgHover = MakeBackgroundTexture(1, 1, new Color32(99, 153, 255, 255));
+            window._reviewButtonStyle = new GUIStyle("button");
+            window._reviewButtonStyle.fontSize = 18;
+            window._reviewButtonStyle.fontStyle = FontStyle.Bold;
+            window._reviewButtonStyle.normal.background = window._reviewButtonBg;
+            window._reviewButtonStyle.active.background = window._reviewButtonBgHover;
+            window._reviewButtonStyle.focused.background = window._reviewButtonBgHover;
+            window._reviewButtonStyle.onFocused.background = window._reviewButtonBgHover;
+            window._reviewButtonStyle.hover.background = window._reviewButtonBgHover;
+            window._reviewButtonStyle.onHover.background = window._reviewButtonBgHover;
+            window._reviewButtonStyle.alignment = TextAnchor.MiddleCenter;
+            window._reviewButtonStyle.normal.textColor = new Color(1, 1, 1, 1);
+
+        }
+
+
+        private static bool _subscribed;
+
+        [InitializeOnLoadMethod]
+        private static void Initialize()
+        {
+            SubscribeToUpdate();
+        }
+
+        private static void SubscribeToUpdate()
+        {
+            if (Application.isBatchMode)
+                return;
+
+            if (!_subscribed && !EditorApplication.isPlayingOrWillChangePlaymode)
+            {
+                _subscribed = true;
+                EditorApplication.update += ShowGettingStarted;
+            }
+        }
+
+        private static void ShowGettingStarted()
+        {
+            EditorApplication.update -= ShowGettingStarted;
+
+            bool shown = EditorPrefs.GetBool(SHOWED_GETTING_STARTED, false);
+            if (!shown)
+            {
+                EditorPrefs.SetBool(SHOWED_GETTING_STARTED, true);
+                ReviewReminderEditor.ResetDateTimeReminded();
+                GettingStartedMenu();
+            }
+            //If was already shown then check review reminder instead.
+            else
+            {
+                ReviewReminderEditor.CheckRemindToReview();
+            }
+        }
+
+
+        void OnGUI()
+        {
+
+
+            GUILayout.Box(_fishnetLogo, GUILayout.Width(this.position.width), GUILayout.Height(128));
+            GUILayout.Space(20);
+
+            GUILayout.Label("Have you considered leaving us a review?", _labelStyle, GUILayout.Width(280));
+
+            GUILayout.Space(10);
+
+            if (GUILayout.Button("Leave us a review!", _reviewButtonStyle))
+            {
+                Application.OpenURL("https://assetstore.unity.com/packages/tools/network/fish-net-networking-evolved-207815");
+            }
+
+            GUILayout.Space(20);
+
+            EditorGUILayout.BeginHorizontal();
+            if (GUILayout.Button("Documentation", GUILayout.Width(this.position.width * 0.485f)))
+            {
+                Application.OpenURL("https://fish-networking.gitbook.io/docs/");
+            }
+
+            if (GUILayout.Button("Discord", GUILayout.Width(this.position.width * 0.485f)))
+            {
+                Application.OpenURL("https://discord.gg/Ta9HgDh4Hj");
+            }
+            EditorGUILayout.EndHorizontal();
+
+            EditorGUILayout.BeginHorizontal();
+            if (GUILayout.Button("FishNet Pro", GUILayout.Width(this.position.width * 0.485f)))
+            {
+                Application.OpenURL("https://fish-networking.gitbook.io/docs/master/pro");
+            }
+
+            if (GUILayout.Button("Github", GUILayout.Width(this.position.width * 0.485f)))
+            {
+                Application.OpenURL("https://github.com/FirstGearGames/FishNet");
+            }
+            EditorGUILayout.EndHorizontal();
+
+            EditorGUILayout.BeginHorizontal();
+            if (GUILayout.Button("Pro Downloads", GUILayout.Width(this.position.width * 0.485f)))
+            {
+                Application.OpenURL("https://www.firstgeargames.com/");
+            }
+
+            if (GUILayout.Button("Examples", GUILayout.Width(this.position.width * 0.485f)))
+            {
+                Application.OpenURL("https://fish-networking.gitbook.io/docs/manual/tutorials/example-projects");
+            }
+            EditorGUILayout.EndHorizontal();
+
+            //GUILayout.Space(20);
+            //_showOnStartupSelected = EditorGUILayout.Popup("Show on Startup", _showOnStartupSelected, showOnStartupOptions);
+        }
+        //private string[] showOnStartupOptions = new string[] { "Always", "On new version", "Never", };
+        //private int _showOnStartupSelected = 1;
+
+        private static Texture2D MakeBackgroundTexture(int width, int height, Color color)
+        {
+            Color[] pixels = new Color[width * height];
+            for (int i = 0; i < pixels.Length; i++)
+                pixels[i] = color;
+            Texture2D backgroundTexture = new Texture2D(width, height);
+            backgroundTexture.SetPixels(pixels);
+            backgroundTexture.Apply();
+            return backgroundTexture;
+        }
+    }
+
+}
+#endif

Assets/FishNet/Runtime/Editor/Configuring/FIshNetGettingStartedEditor.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 335aec9a9dce4944994cb57ac704ba5a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/FishNet/Runtime/Editor/Configuring/ReviewReminderEditor.cs

@@ -0,0 +1,171 @@
+#if UNITY_EDITOR
+using System;
+using UnityEditor;
+using UnityEngine;
+
+namespace FishNet.Editing
+{
+
+    /// <summary>
+    /// Contributed by YarnCat! Thank you!
+    /// </summary>
+    public class ReviewReminderEditor : EditorWindow
+    {
+        private Texture2D _fishnetLogo, _reviewButtonBg, _reviewButtonBgHover;
+        private GUIStyle _labelStyle, _reviewButtonStyle;
+
+        private const string DATETIME_REMINDED = "ReviewDateTimeReminded";
+        private const string CHECK_REMIND_COUNT = "CheckRemindCount";
+        private const string IS_ENABLED = "ReminderEnabled";
+
+        private static ReviewReminderEditor _window;
+
+        internal static void CheckRemindToReview()
+        {
+            bool reminderEnabled = EditorPrefs.GetBool(IS_ENABLED, true);
+            if (!reminderEnabled)
+                return;
+
+            /* Require at least two opens and 10 days
+             * to be passed before reminding. */
+            int checkRemindCount = (EditorPrefs.GetInt(CHECK_REMIND_COUNT, 0) + 1);
+            EditorPrefs.SetInt(CHECK_REMIND_COUNT, checkRemindCount);
+
+            //Not enough checks.
+            if (checkRemindCount < 2)
+                return;
+
+            string dtStr = EditorPrefs.GetString(DATETIME_REMINDED, string.Empty);
+            //Somehow got cleared. Reset.
+            if (string.IsNullOrWhiteSpace(dtStr))
+            {
+                ResetDateTimeReminded();
+                return;
+            }
+            long binary;
+            //Failed to parse.
+            if (!long.TryParse(dtStr, out binary))
+            {
+                ResetDateTimeReminded();
+                return;
+            }
+            //Not enough time passed.
+            DateTime dt = DateTime.FromBinary(binary);
+            if ((DateTime.Now - dt).TotalDays < 10)
+                return;
+
+            //If here then the reminder can be shown.
+            EditorPrefs.SetInt(CHECK_REMIND_COUNT, 0);
+
+            ShowReminder();
+        }
+
+        internal static void ResetDateTimeReminded()
+        {
+            EditorPrefs.SetString(DATETIME_REMINDED, DateTime.Now.ToBinary().ToString());
+        }
+
+        private static void ShowReminder()
+        {
+            InitializeWindow();
+        }
+      
+        static void InitializeWindow()
+        {
+            if (_window != null)
+                return;
+            _window = (ReviewReminderEditor)EditorWindow.GetWindow(typeof(ReviewReminderEditor));
+            _window.position = new Rect(0f, 0f, 320f, 300f);
+            Rect mainPos;
+#if UNITY_2020_1_OR_NEWER
+            mainPos = EditorGUIUtility.GetMainWindowPosition();
+#else
+            mainPos = new Rect(Vector2.zero, Vector2.zero);
+#endif
+            var pos = _window.position;
+            float w = (mainPos.width - pos.width) * 0.5f;
+            float h = (mainPos.height - pos.height) * 0.5f;
+            pos.x = mainPos.x + w;
+            pos.y = mainPos.y + h;
+            _window.position = pos;
+        }
+
+        static void StyleWindow()
+        {
+            InitializeWindow();
+            _window._fishnetLogo = (Texture2D)AssetDatabase.LoadAssetAtPath("Assets/FishNet/Runtime/Editor/Textures/UI/Logo_With_Text.png", typeof(Texture));
+            _window._labelStyle = new GUIStyle("label");
+            _window._labelStyle.fontSize = 24;
+            _window._labelStyle.wordWrap = true;
+            //window.labelStyle.alignment = TextAnchor.MiddleCenter;
+            _window._labelStyle.normal.textColor = new Color32(74, 195, 255, 255);
+
+            _window._reviewButtonBg = MakeBackgroundTexture(1, 1, new Color32(52, 111, 255, 255));
+            _window._reviewButtonBgHover = MakeBackgroundTexture(1, 1, new Color32(99, 153, 255, 255));
+            _window._reviewButtonStyle = new GUIStyle("button");
+            _window._reviewButtonStyle.fontSize = 18;
+            _window._reviewButtonStyle.fontStyle = FontStyle.Bold;
+            _window._reviewButtonStyle.normal.background = _window._reviewButtonBg;
+            _window._reviewButtonStyle.active.background = _window._reviewButtonBgHover;
+            _window._reviewButtonStyle.focused.background = _window._reviewButtonBgHover;
+            _window._reviewButtonStyle.onFocused.background = _window._reviewButtonBgHover;
+            _window._reviewButtonStyle.hover.background = _window._reviewButtonBgHover;
+            _window._reviewButtonStyle.onHover.background = _window._reviewButtonBgHover;
+            _window._reviewButtonStyle.alignment = TextAnchor.MiddleCenter;
+            _window._reviewButtonStyle.normal.textColor = new Color(1, 1, 1, 1);
+
+        }
+
+        void OnGUI()
+        {
+            float thisWidth = this.position.width;
+            StyleWindow();
+            GUILayout.Box(_fishnetLogo, GUILayout.Width(this.position.width), GUILayout.Height(160f));
+            EditorGUILayout.BeginHorizontal();
+            GUILayout.Space(8f);
+            GUILayout.Label("Have you considered leaving us a review?", _labelStyle, GUILayout.Width(thisWidth * 0.95f));
+            EditorGUILayout.EndHorizontal();
+
+            EditorGUILayout.BeginHorizontal();
+            if (GUILayout.Button("Don't Ask Again", GUILayout.Width(this.position.width)))
+            {
+                this.Close();
+                EditorPrefs.SetBool(IS_ENABLED, false);
+            }
+            EditorGUILayout.EndHorizontal();
+
+            EditorGUILayout.BeginHorizontal();
+            if (GUILayout.Button("Ask Later", GUILayout.Width(this.position.width)))
+            {
+                this.Close();
+                Application.OpenURL("https://discord.gg/Ta9HgDh4Hj");
+            }
+            EditorGUILayout.EndHorizontal();
+
+            EditorGUILayout.BeginHorizontal();
+            if (GUILayout.Button("Leave A Review", GUILayout.Width(this.position.width)))
+            {
+                this.Close();
+                EditorPrefs.SetBool(IS_ENABLED, false);
+                Application.OpenURL("https://assetstore.unity.com/packages/tools/network/fish-net-networking-evolved-207815");
+            }
+            EditorGUILayout.EndHorizontal();
+
+            //GUILayout.Space(20);
+            //_showOnStartupSelected = EditorGUILayout.Popup("Show on Startup", _showOnStartupSelected, showOnStartupOptions);
+        }
+
+        private static Texture2D MakeBackgroundTexture(int width, int height, Color color)
+        {
+            Color[] pixels = new Color[width * height];
+            for (int i = 0; i < pixels.Length; i++)
+                pixels[i] = color;
+            Texture2D backgroundTexture = new Texture2D(width, height);
+            backgroundTexture.SetPixels(pixels);
+            backgroundTexture.Apply();
+            return backgroundTexture;
+        }
+    }
+
+}
+#endif

Assets/FishNet/Runtime/Editor/Configuring/ReviewReminderEditor.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 4260206b6a57e4243b56437f8f283084
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/FishNet/Runtime/Editor/Configuring/SettingsProvider.cs

@@ -0,0 +1,86 @@
+#if UNITY_EDITOR
+
+using UnityEngine;
+using UnityEditor;
+using FishNet.Configuring;
+
+using UnitySettingsProviderAttribute = UnityEditor.SettingsProviderAttribute;
+using UnitySettingsProvider = UnityEditor.SettingsProvider;
+using System.Collections.Generic;
+
+namespace FishNet.Configuring.Editing
+{
+    internal static class SettingsProvider
+    {
+        private static Vector2 _scrollView;
+
+        [UnitySettingsProvider]
+        private static UnitySettingsProvider Create()
+        {
+            return new UnitySettingsProvider("Project/Fish-Networking/Configuration", SettingsScope.Project)
+            {
+                label = "Configuration",
+
+                guiHandler = OnGUI,
+
+                keywords = new string[]
+                {
+                    "Fish",
+                    "Networking",
+                    "Configuration",
+                },
+            };
+        }
+
+        private static void OnGUI(string searchContext)
+        {
+            ConfigurationData configuration = Configuration.LoadConfigurationData();
+
+            if (configuration == null)
+            {
+                EditorGUILayout.HelpBox("Unable to load configuration data.", MessageType.Error);
+
+                return;
+            }
+
+            EditorGUI.BeginChangeCheck();
+
+            GUIStyle scrollViewStyle = new GUIStyle()
+            {
+                padding = new RectOffset(10, 10, 10, 10),
+            };
+
+            _scrollView = GUILayout.BeginScrollView(_scrollView, scrollViewStyle);
+
+            EditorGUILayout.BeginHorizontal();
+
+            GUIStyle toggleStyle = new GUIStyle(EditorStyles.toggle)
+            {
+                richText = true,
+            };
+
+            configuration.CodeStripping.StripReleaseBuilds = GUILayout.Toggle(configuration.CodeStripping.StripReleaseBuilds, $"{ObjectNames.NicifyVariableName(nameof(configuration.CodeStripping.StripReleaseBuilds))} <color=yellow>(Pro Only)</color>", toggleStyle);
+
+            EditorGUILayout.EndHorizontal();
+
+            if (configuration.CodeStripping.StripReleaseBuilds)
+            {
+                EditorGUI.indentLevel++;
+                //Stripping Method.
+                List<string> enumStrings = new List<string>();
+                foreach (string item in System.Enum.GetNames(typeof(StrippingTypes)))
+                    enumStrings.Add(item);
+                configuration.CodeStripping.StrippingType = EditorGUILayout.Popup($"{ObjectNames.NicifyVariableName(nameof(configuration.CodeStripping.StrippingType))}", (int)configuration.CodeStripping.StrippingType, enumStrings.ToArray());
+
+                EditorGUILayout.HelpBox("Development builds will not have code stripped. Additionally, if you plan to run as host disable code stripping.", MessageType.Warning);
+                EditorGUI.indentLevel--;
+            }
+
+            GUILayout.EndScrollView();
+
+            if (EditorGUI.EndChangeCheck()) Configuration.Configurations.Write(true);
+        }
+    }
+}
+
+#endif

Assets/FishNet/Runtime/Editor/Configuring/SettingsProvider.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: b3d7d3c45d53dea4e8a0a7da73d64021
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: