StepsDataSO.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text.RegularExpressions;
#if UNITY_EDITOR
using Sirenix.OdinInspector;
using Sirenix.Utilities.Editor;
using PixoVR.Event.Editor;
using UnityEditor;
#endif
using UnityEngine;
 
namespace PixoVR.Event
{
    [CreateAssetMenu(menuName = "Scenarios Data Menu/Create Steps Data", fileName = "StepsData", order = 2)]
    public class StepsDataSO : ScriptableObject
    {
#if UNITY_EDITOR
        [InlineEditor,
         ListDrawerSettings(
                               CustomRemoveElementFunction = "Remove",
                               CustomRemoveIndexFunction = "RemoveAt",
                               CustomAddFunction = "Add",
                               OnBeginListElementGUI = "OnBeginListElementGUI"
                           ), DisableContextMenu(DisableForCollectionElements = true, DisableForMember = false),
         Searchable]
#endif
        public List<StepItemSO> listOfSteps;
 
#if UNITY_EDITOR
        [ReadOnly] public ScenarioInfoSO owner;
 
        public void Add()
        {
            TextInputDialogue.ShowDialogue(
                                           "Enter ID for new step",
                                           stepId =>
                                           {
                                               if (!string.IsNullOrEmpty(stepId))
                                               {
                                                   var stepData = this;
 
                                                   var scenarioPath =
                                                       $"{Path.GetDirectoryName(AssetDatabase.GetAssetPath(this))}";
 
                                                   if (!stepData.listOfSteps.Any(d => d.stepID.Equals(stepId)))
                                                   {
                                                       var stepPath =
                                                           $"{scenarioPath}/{ScenarioEditorWindow.StepsDirectoryName}/{stepId}.asset";
 
                                                       var stepItem = ScriptableObject.CreateInstance<StepItemSO>();
                                                       stepItem.stepID = stepId;
                                                       AssetDatabase.CreateAsset(stepItem, stepPath);
                                                   }
                                                   else
                                                   {
                                                       EditorUtility.DisplayDialog(
                                                            "Add Step Error",
                                                            "Step id exist!",
                                                            "ok"
                                                           );
                                                   }
                                               }
                                               else
                                               {
                                                   EditorUtility.DisplayDialog(
                                                                               "Add Step Error",
                                                                               "Step id is empty",
                                                                               "ok"
                                                                              );
                                               }
 
                                               AssetDatabase.Refresh();
                                           }
                                          );
        }
 
        public void RemoveAt(int index)
        {
            AssetDatabase.DeleteAsset(AssetDatabase.GetAssetPath(this.listOfSteps[index]));
            AssetDatabase.Refresh();
            Validate();
        }
 
        public void Remove(StepItemSO item)
        {
            RemoveAt(listOfSteps.IndexOf(item));
        }
 
        public void OnBeginListElementGUI(int index)
        {
            SirenixEditorGUI.BeginHorizontalToolbar();
 
            if (SirenixEditorGUI.ToolbarButton("Duplicate"))
            {
                TextInputDialogue.ShowDialogue(
                                               "Enter ID for new step",
                                               stepId =>
                                               {
                                                   if (!string.IsNullOrEmpty(stepId))
                                                   {
                                                       var stepData = this;
 
                                                       var scenarioPath =
                                                           $"{Path.GetDirectoryName(AssetDatabase.GetAssetPath(this))}";
 
                                                       if (!stepData.listOfSteps.Any(d => d.stepID.Equals(stepId)))
                                                       {
                                                           var stepPath =
                                                               $"{scenarioPath}/{ScenarioEditorWindow.StepsDirectoryName}/{stepId}.asset";
 
                                                           var stepItem =
                                                               ScriptableObject.Instantiate(listOfSteps[index]);
 
                                                           stepItem.stepID = stepId;
                                                           AssetDatabase.CreateAsset(stepItem, stepPath);
                                                       }
                                                       else
                                                       {
                                                           EditorUtility.DisplayDialog(
                                                                "Add Step Error",
                                                                "Step id exist!",
                                                                "ok"
                                                               );
                                                       }
                                                   }
                                                   else
                                                   {
                                                       EditorUtility.DisplayDialog(
                                                            "Add Step Error",
                                                            "Step id is empty",
                                                            "ok"
                                                           );
                                                   }
 
                                                   AssetDatabase.Refresh();
                                               }
                                              );
            }
 
            if (SirenixEditorGUI.ToolbarButton("Rename"))
            {
                TextInputDialogue.ShowDialogue(
                                               "Enter new ID name",
                                               stepId =>
                                               {
                                                   var step = listOfSteps[index];
 
                                                   if (string.IsNullOrEmpty(stepId) || !step.ValidateID(stepId))
 
                                                   {
                                                       EditorUtility.DisplayDialog(
                                                            "Rename Error",
                                                            "Invalid step ID: " + stepId,
                                                            "ok"
                                                           );
                                                   }
                                                   else
 
                                                   {
                                                       step.stepID = stepId;
                                                       EditorUtility.SetDirty(step);
                                                       AssetDatabase.SaveAssetIfDirty(step);
                                                       AssetDatabase.Refresh();
 
                                                       AssetDatabase.RenameAsset(
                                                            AssetDatabase.GetAssetPath(step),
                                                            stepId
                                                           );
 
                                                       AssetDatabase.Refresh();
                                                   }
                                               }
                                              );
            }
 
            SirenixEditorGUI.EndHorizontalToolbar();
        }
 
        public void Rebuild()
        {
            var scenarioPath = $"{Path.GetDirectoryName(AssetDatabase.GetAssetPath(this))}";
 
            var stepsPath = $"{scenarioPath}/{ScenarioEditorWindow.StepsDirectoryName}";
 
            listOfSteps = new List<StepItemSO>();
 
            // Find all Texture2Ds that have 'co' in their filename, that are labelled with 'architecture' and are placed in 'MyAwesomeProps' folder
            string[] guids = AssetDatabase.FindAssets("t:StepItemSO", new[] {stepsPath});
 
            foreach (string guid in guids)
            {
                listOfSteps.Add(AssetDatabase.LoadAssetAtPath<StepItemSO>(AssetDatabase.GUIDToAssetPath(guid)));
            }
 
            // listOfSteps.Sort((s, s2) => String.Compare(s.item.stepID, s2.item.stepID, StringComparison.Ordinal));
            EditorUtility.SetDirty(this);
        }
#endif
 
        public StepItem GetStepItem(string stepID = "")
        {
            if (stepID == string.Empty)
            {
                return listOfSteps[0].item;
            }
 
            for (int i = 0; i < listOfSteps.Count; i++)
            {
                if (listOfSteps[i].item.stepID == stepID)
                {
                    return listOfSteps[i].item;
                }
            }
 
            return null;
        }
#if UNITY_EDITOR
        public void Validate()
        {
            Rebuild();
            Debug.Log($"StepsData {name} validation begin");
 
            for (int i = 0; i < listOfSteps.Count; i++)
            {
                listOfSteps[i].Validate();
                var v1 = listOfSteps[i].stepID;
 
                if (Regex.IsMatch(v1, @"\p{IsCyrillic}"))
                {
                    Debug.LogError($"StepsData {v1} Cyrillic symbol presented!!");
                }
 
                for (int j = i + 1; j < listOfSteps.Count; j++)
                {
                    var v2 = listOfSteps[j].stepID;
 
                    if (v1.Equals(v2))
                    {
                        Debug.LogError($"StepsData {v1} duplicates at position {i}:{j}");
                    }
                }
            }
 
            Debug.Log($"StepsData {name} validation finish");
        }
#endif
    }
}