Refactoring code

.vsconfig

@@ -0,0 +1,6 @@
+{
+  "version": "1.0",
+  "components": [ 
+    "Microsoft.VisualStudio.Workload.ManagedGame"
+  ]
+} 

Assets/Group1/Plugins/TypedScenes/Core/ISceneLoadHandler.cs

@@ -0,0 +1,7 @@
+namespace IJunior.TypedScenes
+{
+    public interface ISceneLoadHandler<T>
+    {
+        void OnSceneLoaded(T argument);
+    }
+}

Assets/Group1/Plugins/TypedScenes/Core/ITypedAwakeHandler.cs

@@ -0,0 +1,7 @@
+namespace IJunior.TypedScenes
+{
+    public interface ITypedAwakeHandler
+    {
+        void OnSceneAwake();
+    } 
+}

Assets/Group1/Plugins/TypedScenes/Core/SceneAnalyzer.cs

@@ -0,0 +1,113 @@
+#if UNITY_EDITOR
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using UnityEditor;
+using UnityEditor.SceneManagement;
+using UnityEngine;
+using UnityEngine.SceneManagement;
+
+namespace IJunior.TypedScenes
+{
+    public class SceneAnalyzer
+    {
+        public static IEnumerable<Type> GetLoadingParameters(string sceneGUID)
+        {
+            var loadParameters = new HashSet<Type>();
+            loadParameters.Add(null);
+
+            TryAnalyseScene(sceneGUID, scene =>
+            {
+                var componentTypes = GetAllTypes(scene);
+
+                foreach (var type in componentTypes)
+                {
+                    if (type.GetInterfaces().Any(x => x.IsGenericType && x.GetGenericTypeDefinition() == typeof(ISceneLoadHandler<>)))
+                    {
+                        var loadMethods = type.GetMethods().Where(method => method.Name == "OnSceneLoaded");
+                        foreach (var method in loadMethods)
+                        {
+                            loadParameters.Add(method.GetParameters()[0].ParameterType);
+                        }
+                    }
+                }
+            });
+
+            if (loadParameters.Count > 1)
+                loadParameters.Remove(null);
+
+            return loadParameters;
+        }
+
+        public static bool TryAddTypedProcessor(string sceneGUID)
+        {
+            var added = false;
+
+            TryAnalyseScene(sceneGUID, scene =>
+            {
+                var componentTypes = GetAllTypes(scene);
+
+                if (!componentTypes.Contains(typeof(TypedProcessor)))
+                {
+                    var gameObject = new GameObject("TypedProcessor");
+                    gameObject.AddComponent<TypedProcessor>();
+                    scene.GetRootGameObjects().Append(gameObject);
+                    Undo.RegisterCreatedObjectUndo(gameObject, "Typed processor added");
+                    EditorSceneManager.SaveScene(scene);
+                    added = true;
+                }
+            });
+
+            return added;
+        }
+
+        private static void TryAnalyseScene(string sceneGUID, Action<Scene> analyser)
+        {
+            var scene = SceneManager.GetActiveScene();
+            var currentPath = scene.path;
+            var targetPath = AssetDatabase.GUIDToAssetPath(sceneGUID);
+
+            if (targetPath == currentPath)
+            {
+                analyser(scene);
+                return;
+            }
+
+            if (File.Exists(targetPath))
+            {
+                scene = EditorSceneManager.OpenScene(targetPath, OpenSceneMode.Additive);
+                SceneManager.SetActiveScene(scene);
+                analyser(scene);
+                EditorSceneManager.CloseScene(scene, true);
+            }
+        }
+
+        private static IEnumerable<Component> GetAllComponents(Scene activeScene)
+        {
+            var rootObjects = activeScene.GetRootGameObjects();
+            var components = new List<Component>();
+
+            foreach (var gameObject in rootObjects)
+            {
+                components.AddRange(gameObject.GetComponentsInChildren<Component>());
+            }
+
+            return components;
+        }
+
+        private static IEnumerable<Type> GetAllTypes(Scene activeScene)
+        {
+            var components = GetAllComponents(activeScene);
+            var types = new HashSet<Type>();
+
+            foreach (var component in components)
+            {
+                types.Add(component.GetType());
+            }
+
+            return types;
+        }
+    }
+}
+#endif

Assets/Group1/Plugins/TypedScenes/Core/ScenePostprocessor.cs

@@ -0,0 +1,70 @@
+#if UNITY_EDITOR
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using UnityEditor;
+
+namespace IJunior.TypedScenes
+{
+    public class ScenePostprocessor : AssetPostprocessor
+    {
+        private static void OnPostprocessAllAssets(string[] importedAssets, string[] deletedAssets, string[] movedAssets, string[] movedFromAssetPaths)
+        {
+            DetectSceneImport(importedAssets);
+            DetectSceneDeletion(deletedAssets);
+            DetectSceneMovement(movedAssets, movedFromAssetPaths);
+        }
+
+        private static void DetectSceneImport(string[] importedAssets)
+        {
+            foreach (string assetPath in importedAssets)
+            {
+                if (Path.GetExtension(assetPath) == TypedSceneSettings.SceneExtension
+                    && TypedSceneValidator.ValidateSceneImport(assetPath))
+                {
+                    var name = Path.GetFileNameWithoutExtension(assetPath);
+                    var sourceCode = TypedSceneGenerator.Generate(name, name, AssetDatabase.AssetPathToGUID(assetPath));
+                    var guid = AssetDatabase.AssetPathToGUID(assetPath);
+                    if (!EditorBuildSettings.scenes.Any(scene => scene.guid.ToString() == guid))
+                    {
+                        var newSceneList = new List<EditorBuildSettingsScene>(EditorBuildSettings.scenes);
+                        newSceneList.Add(new EditorBuildSettingsScene(assetPath, true));
+                        EditorBuildSettings.scenes = newSceneList.ToArray();
+                    }
+                    TypedSceneStorage.Save(name, sourceCode);
+                }
+            }
+        }
+
+        private static void DetectSceneDeletion(string[] deletedAssets)
+        {
+            foreach (string assetPath in deletedAssets)
+            {
+                if (Path.GetExtension(assetPath) == TypedSceneSettings.SceneExtension
+                    && !TypedSceneValidator.ValidateSceneDeletion(Path.GetFileNameWithoutExtension(assetPath)))
+                {
+                    var newSceneList = new List<EditorBuildSettingsScene>(EditorBuildSettings.scenes);
+                    newSceneList.RemoveAll(scene => scene.path == assetPath);
+                    EditorBuildSettings.scenes = newSceneList.ToArray();
+                    TypedSceneStorage.Delete(Path.GetFileNameWithoutExtension(assetPath));
+                }
+            }
+        }
+
+        private static void DetectSceneMovement(string[] movedAssets, string[] movedFromAssetPaths)
+        {
+            for (var i = 0; i < movedFromAssetPaths.Length; i++)
+            {
+                if (Path.GetExtension(movedFromAssetPaths[i]) == TypedSceneSettings.SceneExtension)
+                {
+                    var oldName = Path.GetFileNameWithoutExtension(movedFromAssetPaths[i]);
+                    var newName = Path.GetFileNameWithoutExtension(movedAssets[i]);
+
+                    if (oldName != newName)
+                        TypedSceneStorage.Delete(oldName);
+                }
+            }
+        }
+    }
+}
+#endif

Assets/Group1/Plugins/TypedScenes/Core/TypedProcessor.cs

@@ -0,0 +1,16 @@
+using System.Linq;
+using UnityEngine;
+
+namespace IJunior.TypedScenes
+{
+    public class TypedProcessor : MonoBehaviour
+    {
+        private void Awake()
+        {
+            foreach(var handler in FindObjectsOfType<MonoBehaviour>().OfType<ITypedAwakeHandler>())
+            {
+                handler.OnSceneAwake();
+            }
+        }
+    }
+}

Assets/Group1/Plugins/TypedScenes/Core/TypedScene.cs

@@ -0,0 +1,47 @@
+using System;
+using UnityEngine;
+using UnityEngine.SceneManagement;
+
+namespace IJunior.TypedScenes
+{
+    public abstract class TypedScene
+    {
+        protected static void LoadScene(string sceneName, LoadSceneMode loadSceneMode)
+        {
+            Action<AsyncOperation> handler = null;
+            handler = asyncOperation =>
+            {
+                SceneManager.SetActiveScene(SceneManager.GetSceneByName(sceneName));
+                asyncOperation.completed -= handler;
+            };
+
+            var loader = SceneManager.LoadSceneAsync(sceneName, loadSceneMode);
+            loader.completed += handler;
+        }
+
+        protected static void LoadScene<T>(string sceneName, LoadSceneMode loadSceneMode, T argument)
+        {
+            Action<AsyncOperation> handler = null;
+            handler = asyncOperation =>
+            {
+                SceneManager.SetActiveScene(SceneManager.GetSceneByName(sceneName));
+                HandleSceneLoaders(argument);
+                asyncOperation.completed -= handler;
+            };
+
+            var loader = SceneManager.LoadSceneAsync(sceneName, loadSceneMode);
+            loader.completed += handler;
+        }
+
+        private static void HandleSceneLoaders<T>(T loadingModel)
+        {
+            foreach (var rootObjects in SceneManager.GetActiveScene().GetRootGameObjects())
+            {
+                foreach (var handler in rootObjects.GetComponentsInChildren<ISceneLoadHandler<T>>())
+                {
+                    handler.OnSceneLoaded(loadingModel);
+                }
+            }
+        }
+    }
+}