Untitled

using UnityEngine;
using System.Collections.Generic;
using TransitionsPlus;

#if UNITY_EDITOR
using UnityEditor;
#endif

namespace AC
{
    public enum TransitionBackgroundType
    {
        Color,
        Texture
    }

    [System.Serializable]
    public class ActionSceneSwitchTransition : Action
    {
        public ChooseSceneBy chooseSceneBy = ChooseSceneBy.Number;
        public int sceneNumber;
        public int sceneNumberParameterID = -1;
        public string sceneName;
        public int sceneNameParameterID = -1;
        public bool assignScreenOverlay;
        public bool onlyPreload = false;

        // TransitionPlus parameters
        public bool useTransitionPlus = false;
        public TransitionType transitionType = TransitionType.Fade;
        public float transitionDuration = 2f;
        public TransitionBackgroundType transitionBackgroundType = TransitionBackgroundType.Color;
        public Color transitionColor = Color.black;
        public Texture2D transitionTexture;
        public float noiseIntensity = 0.5f;
        public float contrast = 1f;
        public float rotation = 0f;
        
        public bool relativePosition = false;
        public Marker relativeMarker;
        protected Marker runtimeRelativeMarker;
        public int relativeMarkerID;
        public int relativeMarkerParameterID = -1;
        public bool forceReload = false;

        public override ActionCategory Category { get { return ActionCategory.Scene; }}
        public override string Title { get { return "Scene Switch Transition"; }}
        public override string Description { get { return "Moves the Player to a new scene with transition effects using TransitionPlus."; }}
        public override int NumSockets { get { return (onlyPreload || isAssetFile) ? 1 : 0; }}

        public override void AssignValues(List<ActionParameter> parameters)
        {
            sceneNumber = AssignInteger(parameters, sceneNumberParameterID, sceneNumber);
            sceneName = AssignString(parameters, sceneNameParameterID, sceneName);
            runtimeRelativeMarker = AssignFile<Marker>(parameters, relativeMarkerParameterID, relativeMarkerID, relativeMarker);
        }

        public override float Run()
        {
            string runtimeSceneName = "";
            
            switch (KickStarter.settingsManager.referenceScenesInSave)
            {
                case ChooseSceneBy.Name:
                    runtimeSceneName = (chooseSceneBy == ChooseSceneBy.Name) ? sceneName : KickStarter.sceneChanger.IndexToName(sceneNumber);
                    break;

                case ChooseSceneBy.Number:
                default:
                    int runtimeSceneIndex = (chooseSceneBy == ChooseSceneBy.Name) ? KickStarter.sceneChanger.NameToIndex(sceneName) : sceneNumber;
                    if (runtimeSceneIndex >= 0)
                    {
                        runtimeSceneName = KickStarter.sceneChanger.IndexToName(runtimeSceneIndex);
                    }
                    break;
            }

            if (string.IsNullOrEmpty(runtimeSceneName))
            {
                LogWarning("Scene name is empty or invalid");
                return 0f;
            }

            if (onlyPreload)
            {
                if (KickStarter.settingsManager.useAsyncLoading)
                {
                    KickStarter.sceneChanger.PreloadScene(runtimeSceneName);
                }
                return 0f;
            }

            if (useTransitionPlus)
            {
                if (relativePosition && runtimeRelativeMarker != null)
                {
                    KickStarter.sceneChanger.SetRelativePosition(runtimeRelativeMarker);
                }

                // Start transition
                if (transitionBackgroundType == TransitionBackgroundType.Color)
                {
                    TransitionAnimator.Start(
                        transitionType,
                        duration: transitionDuration,
                        color: transitionColor,
                        noiseIntensity: noiseIntensity,
                        contrast: contrast,
                        rotation: rotation,
                        sceneNameToLoad: runtimeSceneName,
                        autoDestroy: true,
                        destroyDelay: 0.1f
                    );
                }
                else if (transitionTexture != null)
                {
                    TransitionAnimator.Start(
                        transitionType,
                        duration: transitionDuration,
                        texture: transitionTexture,
                        noiseIntensity: noiseIntensity,
                        contrast: contrast,
                        rotation: rotation,
                        sceneNameToLoad: runtimeSceneName,
                        autoDestroy: true,
                        destroyDelay: 0.1f
                    );
                }
                
                return transitionDuration;
            }
            else
            {
                if (relativePosition && runtimeRelativeMarker != null)
                {
                    KickStarter.sceneChanger.SetRelativePosition(runtimeRelativeMarker);
                }

                KickStarter.sceneChanger.ChangeScene(runtimeSceneName, true, forceReload, assignScreenOverlay);
                return 0f;
            }
        }

        #if UNITY_EDITOR

        public override void ShowGUI(List<ActionParameter> parameters)
        {
            EditorGUILayout.BeginVertical();
            
            chooseSceneBy = (ChooseSceneBy)EditorGUILayout.EnumPopup("Choose scene by:", chooseSceneBy);
            if (chooseSceneBy == ChooseSceneBy.Name)
            {
                TextField("Scene name:", ref sceneName, parameters, ref sceneNameParameterID);
            }
            else
            {
                IntField("Scene number:", ref sceneNumber, parameters, ref sceneNumberParameterID);
            }

            EditorGUILayout.Space();
            onlyPreload = EditorGUILayout.ToggleLeft("Don't change scene, just preload data?", onlyPreload);

            if (!onlyPreload)
            {
                EditorGUILayout.Space(10);
                EditorGUILayout.BeginVertical(EditorStyles.helpBox);
                
                useTransitionPlus = EditorGUILayout.ToggleLeft("Use TransitionPlus effects?", useTransitionPlus);
                EditorGUILayout.Space(5);

                EditorGUILayout.BeginVertical(EditorStyles.helpBox);
                forceReload = EditorGUILayout.ToggleLeft("Reload even if scene is already open?", forceReload);
                assignScreenOverlay = EditorGUILayout.ToggleLeft("Overlay current screen during switch?", assignScreenOverlay);
                EditorGUILayout.EndVertical();

                if (useTransitionPlus)
                {
                    EditorGUILayout.BeginVertical(EditorStyles.helpBox);
                    EditorGUILayout.LabelField("TransitionPlus Settings", EditorStyles.boldLabel);
                    EditorGUI.indentLevel++;
                    
                    transitionType = (TransitionType)EditorGUILayout.EnumPopup("Transition type:", transitionType);
                    EditorGUILayout.Space(2);
                    transitionDuration = EditorGUILayout.FloatField("Duration (seconds):", transitionDuration);
                    EditorGUILayout.Space(2);

                    transitionBackgroundType = (TransitionBackgroundType)EditorGUILayout.EnumPopup("Background type:", transitionBackgroundType);
                    EditorGUILayout.Space(2);

                    if (transitionBackgroundType == TransitionBackgroundType.Color)
                    {
                        transitionColor = EditorGUILayout.ColorField("Transition color:", transitionColor);
                    }
                    else
                    {
                        transitionTexture = (Texture2D)EditorGUILayout.ObjectField("Transition texture:", transitionTexture, typeof(Texture2D), false);
                    }

                    EditorGUILayout.Space(2);
                    noiseIntensity = EditorGUILayout.Slider("Noise intensity:", noiseIntensity, 0f, 1f);
                    EditorGUILayout.Space(2);
                    contrast = EditorGUILayout.FloatField("Contrast:", contrast);
                    EditorGUILayout.Space(2);
                    rotation = EditorGUILayout.FloatField("Rotation:", rotation);
                    
                    EditorGUI.indentLevel--;
                    EditorGUILayout.EndVertical();
                }

                EditorGUILayout.EndVertical();
                EditorGUILayout.Space(10);

                EditorGUILayout.BeginVertical(EditorStyles.helpBox);
                relativePosition = EditorGUILayout.ToggleLeft("Position Player relative to Marker?", relativePosition);
                if (relativePosition)
                {
                    EditorGUI.indentLevel++;
                    ComponentField("Relative Marker:", ref relativeMarker, ref relativeMarkerID, parameters, ref relativeMarkerParameterID);
                    EditorGUI.indentLevel--;
                }
                EditorGUILayout.EndVertical();
            }

            EditorGUILayout.EndVertical();
        }

        public override void AssignConstantIDs(bool saveScriptsToo, bool fromAssetFile)
        {
            relativeMarkerID = AssignConstantID(relativeMarker, relativeMarkerID, relativeMarkerParameterID);
        }

        public override string SetLabel()
        {
            if (chooseSceneBy == ChooseSceneBy.Name)
            {
                return sceneName;
            }
            return sceneNumber.ToString();
        }

        #endif
    }
}