net.dreditor.chapterselection 0.0.0-stage → 0.1.6

package/ChapterSceneByLatestObjective.cs

@@ -0,0 +1,189 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+using DREditor.Progressing;
+using DREditor.Progressing.Handling;
+using DREditor.Saving;
+using DREditor.Services;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace DREditor.ChapterSelection
+{
+    /// <summary>
+    ///
+    /// </summary>
+    [ClassHeader(nameof(ChapterSelectFallbackEvaluator) + ", " + nameof(IDRELoadableManager) +
+        "\n\n")]
+    public class ChapterSceneByLatestObjective : ChapterSelectFallbackEvaluator, IDRELoadableManager
+    {
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected ChapterSelectDatabase chapterSelectDatabase = null;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected ProgressionDatabase progressionDatabase = null;
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Header("")]
+        [Divider]
+        [Tooltip("")]
+        [SerializeField] protected string objectiveKey = "CurrentObjective";
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected string progressionDataKey = "ProgressionData";
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected string deathsKey = "deadList";
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected string chapterKey = "chapter";
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected Objective loadedCurrentObjective = null;
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected int loadedProgressionIndex = -1;
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected List<string> loadedDeaths = new();
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected int loadedChapter = 0;
+
+
+        /// <inheritdoc/>
+        public virtual void LoadManager(Dictionary<string, object> saveDatas, bool inChapterSelect) => 
+            StartCoroutine(BufferLoad(saveDatas, inChapterSelect));
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="saveDatas"></param>
+        /// <param name="inChapterSelect"></param>
+        protected virtual IEnumerator BufferLoad(Dictionary<string, object> saveDatas, bool inChapterSelect)
+        {
+            yield return null;
+
+            loadedChapter = saveDatas.Get<int>(chapterKey);
+
+            loadedCurrentObjective = saveDatas.Get<Objective>(objectiveKey);
+
+            loadedProgressionIndex = ServiceLocator.GetService<IHistory>().GetObjectiveCountFromHistory(loadedChapter) - 1;
+
+            if (saveDatas.TryGetValue(deathsKey, out object dead) && dead is List<string> deaths)
+                loadedDeaths = deaths;
+        }
+
+
+        /// <inheritdoc/>
+        public override int GetMaxScene(ChapterSectionBase parentSection)
+        {
+            int loadedObjectiveIndex = progressionDatabase.GetObjectiveInt(loadedChapter, loadedCurrentObjective, loadedProgressionIndex);
+
+            if (loadedObjectiveIndex < 0)
+                UnityEngine.Debug.LogError($"ALERT: Chapter Select: A problem has arisen in the {nameof(ChapterSceneHandler)}");
+
+            int maxChapter = parentSection.GetMaxSection();
+
+            Chapter chapter = progressionDatabase.Chapters[maxChapter];
+
+            for (int i = 0; i < chapterSelectDatabase[maxChapter].GetDataCount(); i++)
+            {
+                SceneDataProviderBase data = chapterSelectDatabase[maxChapter][i];
+
+                var saveDict = ((SerializableDictionary)data.GetData()).ToDictionary();
+
+                Objective saveObjective = chapter.GetObjective(saveDict.Get<Objective>(objectiveKey).Description);
+
+                int sceneObjectiveIndex = chapter.Objectives.IndexOf(saveObjective);
+
+                List<string> sceneDeaths = saveDict.Get<List<string>>(deathsKey);
+
+                if (sceneObjectiveIndex > loadedObjectiveIndex ||
+                    (sceneObjectiveIndex <= loadedObjectiveIndex && HasMoreDead(sceneDeaths)))
+                    return chapterSelectDatabase[maxChapter][i - 1].selectScene;
+                else if (sceneObjectiveIndex == loadedObjectiveIndex && MatchesDead(sceneDeaths))
+                    return data.selectScene;
+            }
+
+            return 0;
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="sceneDeaths"></param>
+        /// <returns></returns>
+        protected virtual bool HasMoreDead(List<string> sceneDeaths) => sceneDeaths == null || sceneDeaths.Count > loadedDeaths.Count;
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="sceneDeaths"></param>
+        /// <returns></returns>
+        protected virtual bool MatchesDead(List<string> sceneDeaths) => sceneDeaths == null || sceneDeaths.Count == loadedDeaths.Count;
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="sceneData"></param>
+        /// <param name="parentSection"></param>
+        /// <returns></returns>
+        public override bool SceneIsValid(SceneDataProviderBase sceneData, ChapterSectionBase parentSection)
+        {
+            if (sceneData.GetData() is SerializableDictionary dataEntries &&
+                dataEntries.ToDictionary() is Dictionary<string, object> sceneSaveDatas)
+            {
+                var sceneObjective = sceneSaveDatas.Get<Objective>(objectiveKey);
+
+                int sceneObjectiveIndex = progressionDatabase.GetObjectiveIndex(loadedChapter, sceneObjective);
+
+                try
+                {
+                    int historyObjectiveCount = ServiceLocator.GetService<IHistory>()
+                        .GetObjectiveCountFromHistory(parentSection.GetSelectedSection());
+
+                    return loadedChapter >= parentSection.DefaultUnlockedSections && sceneObjectiveIndex <= historyObjectiveCount;
+                }
+                catch (Exception exception)
+                {
+                    UnityEngine.Debug.LogWarning(ToString() + ": ALERT: There was an issue evaluating the progression history.");
+
+                    UnityEngine.Debug.LogException(exception);
+
+                    return false;
+                }
+            }
+
+            return false;
+        }
+    }
+}

package/ChapterSceneByLatestObjective.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: ec6a49c1302708c42b5b5b8752182f52

package/ChapterSceneHandler.cs

@@ -0,0 +1,152 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+using DREditor.Processables;
+using DREditor.Saving;
+using DREditor.Services;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace DREditor.ChapterSelection
+{
+    /// <summary>
+    ///
+    /// </summary>
+    [ClassHeader(nameof(ChapterSubSectionBase) + ", " + nameof(ChapterSectionBase) + ", " + nameof(IDRELoadableManager) +
+        "\n\n")]
+    public class ChapterSceneHandler : ChapterSubSectionBase
+    {
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected ChapterSectionBase parentSection = null;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected ChapterSelectFallbackEvaluator fallbackEvaluator = null;
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected bool inDefaultMode = false;
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected ChapterSelectData chapterSelectData = null;
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected List<int> moments = new();
+
+
+        /// <inheritdoc/>
+        public override void InitializeDefault()
+        {
+            SetMaxSection(defaultUnlockedSections);
+
+            inDefaultMode = true;
+        }
+
+        /// <inheritdoc/>
+        public override void InitializeLoaded()
+        {
+            SetMaxSection(GetMaxLoadedScene());
+
+            inDefaultMode = false;
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <returns></returns>
+        protected int GetMaxLoadedScene()
+        {
+            ServiceLocator.HasService(out IChapterSelectData chapterSelectData);
+
+            var chapterScenes = chapterSelectDatabase[parentSection.GetMaxSection()].Details;
+
+            foreach (var scene in chapterScenes)
+                if (chapterSelectData is IIdentifiableValidator validator && validator.IDValid(scene.ID))
+                    return chapterScenes.IndexOf(scene);
+
+            return fallbackEvaluator.GetMaxScene(parentSection);
+        }
+
+
+        #region Evaluate Chapter Scene Moment
+
+        /// <inheritdoc/>
+        public override void OnParentSubmittedIndex(int selectedIndex) => EvaluateChapterScene(selectedIndex);
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="currentButtonIndex"></param>
+        public virtual void EvaluateChapterScene(int currentButtonIndex)
+        {
+            chapterSelectData = chapterSelectDatabase[currentButtonIndex];
+
+            moments.Clear();
+
+            EvaluateChapterSelectMoments();
+
+            ActivateValidSceneMoments();
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void EvaluateChapterSelectMoments()
+        {
+            foreach (SceneDataProviderBase sceneData in chapterSelectData)
+                CheckValidChapterSceneData(sceneData);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="sceneData"></param>
+        protected virtual void CheckValidChapterSceneData(SceneDataProviderBase sceneData)
+        {
+            bool shouldAdd = chapterSelectData.chapter < parentSection.GetMaxSection() ||
+                (inDefaultMode && parentSection.SectionIsDefaultUnlocked() && sceneData.selectScene <= maxSection) ||
+                (!inDefaultMode && SceneIsValid(sceneData)) ||
+                (!inDefaultMode && sceneData.selectScene <= maxSection);
+
+            if (shouldAdd)
+                moments.Add(sceneData.selectScene);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="sceneData"></param>
+        /// <returns></returns>
+        protected virtual bool SceneIsValid(SceneDataProviderBase sceneData)
+        {
+            if (ServiceLocator.HasService(out IChapterSelectData chapterSelectData) &&
+                chapterSelectData is IIdentifiableValidator validator)
+                return validator.IDValid(sceneData.ID);
+
+            UnityEngine.Debug.LogWarning("ANALYSIS: CHAPTER SELECT IS USING ITS FALLBACK EVALUATOR.");
+
+            return fallbackEvaluator != null && fallbackEvaluator.SceneIsValid(sceneData, parentSection);
+        }
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void ActivateValidSceneMoments()
+        {
+            for (int i = 0; i < sectionButtons.Count; i++)
+                sectionButtons[i].gameObject.SetActive(moments.Contains(i));
+        }
+
+        #endregion
+    }
+}

package/ChapterSceneHandler.cs.meta

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

package/ChapterSectionBase.cs

@@ -0,0 +1,140 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+using DREditor.Progressing.Handling;
+using DREditor.Saving;
+using DREditor.Services;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace DREditor.ChapterSelection
+{
+    /// <summary>
+    ///
+    /// </summary>
+    public abstract class ChapterSectionBase : MonoBehaviour, IDRELoadableManager
+    {
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected ChapterSelectDatabase chapterSelectDatabase = null;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected string chapterKey = "chapter";
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected int defaultUnlockedSections = -1;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected List<Button> sectionButtons = new();
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected int maxSection = 0;
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected int selectedSection = 0;
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected int loadedChapter = 0;
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        public virtual int DefaultUnlockedSections { get => defaultUnlockedSections; set => defaultUnlockedSections = value; }
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <returns></returns>
+        public virtual int GetSelectedSection() => selectedSection;
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <returns></returns>
+        public virtual int GetMaxSection() => maxSection;
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="maxSection"></param>
+        protected virtual void SetMaxSection(int maxSection) => this.maxSection = maxSection;
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="selectedIndex"></param>
+        public abstract void OnParentSubmittedIndex(int selectedIndex);
+
+        /// <summary>
+        ///
+        /// </summary>
+        public abstract void InitializeDefault();
+
+        /// <summary>
+        ///
+        /// </summary>
+        public abstract void InitializeLoaded();
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <returns></returns>
+        public virtual bool AllowsChapterSelect() => DefaultUnlockedSections >= 0;
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <remarks>
+        ///
+        /// </remarks>
+        /// <param name="button"></param>
+        public virtual void SetSelectedSection(Button button) => selectedSection = sectionButtons.IndexOf(button);
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <returns></returns>
+        public virtual bool SectionIsDefaultUnlocked() => selectedSection == DefaultUnlockedSections;
+
+
+        /// <inheritdoc/>
+        public virtual void LoadManager(Dictionary<string, object> saveDatas, bool inChapterSelect) => 
+            StartCoroutine(BufferLoad(saveDatas, inChapterSelect));
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="saveDatas"></param>
+        /// <param name="inChapterSelect"></param>
+        protected virtual IEnumerator BufferLoad(Dictionary<string, object> saveDatas, bool inChapterSelect)
+        {
+            yield return null;
+
+            var historyChapter = ServiceLocator.GetService<IHistory>().LatestChapterIndex();
+
+            loadedChapter = historyChapter >= 0 ? historyChapter : saveDatas.Get<int>(chapterKey);
+        }
+    }
+}

package/ChapterSectionBase.cs.meta

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

package/ChapterSelectCollection.cs

@@ -0,0 +1,49 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Serialization;
+
+namespace DREditor.ChapterSelection
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    public abstract class ChapterSelectCollection<T> : ChapterSelectCollectionBase, IEnumerable<T>
+    {
+        /// <summary>
+        /// 
+        /// </summary>
+        [FormerlySerializedAs("ChapterScenes")]
+        [FormerlySerializedAs("ChapterDatas")]
+        [Tooltip("")]
+        [SerializeField] protected List<T> chapterSelectDetails = new();
+
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public virtual List<T> Details => chapterSelectDetails;
+
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="i"></param>
+        /// <returns></returns>
+        public virtual T this[int i] => chapterSelectDetails[i];
+
+
+        public override IList GetCollection() => Details;
+
+
+        public virtual IEnumerator<T> GetEnumerator()
+        {
+            foreach (var detail in chapterSelectDetails)
+                yield return detail;
+        }
+
+        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+    }
+}

package/ChapterSelectCollection.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 5f724ca25b6a1e64d82a799bccf1eeaf

package/ChapterSelectCollectionBase.cs

@@ -0,0 +1,72 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace DREditor.ChapterSelection
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public abstract class ChapterSelectCollectionBase : ScriptableObject
+    {
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="collection"></param>
+        /// <returns></returns>
+        public virtual bool TryGetCollection<T>(out List<T> collection)
+        {
+            collection = GetCollection() is List<T> castedCollection ? castedCollection : null;
+
+            bool result = collection != null;
+
+            if (!result)
+                Debug.LogWarning($"ALERT: {name}'s collection is not of type: {typeof(T).Name}!");
+
+            return result;
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <returns></returns>
+        public abstract IList GetCollection();
+
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <returns></returns>
+        public virtual bool IsEmpty() => CollectionCountEmpty() || ChildrenAreEmpty();
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <returns></returns>
+        protected virtual bool ChildrenAreEmpty()
+        {
+            IList collection = GetCollection();
+
+            foreach (var item in collection)
+                if (item is ChapterSelectCollectionBase childCollection && childCollection.IsEmpty())
+                    return true;
+
+            return false;
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <returns></returns>
+        private bool CollectionCountEmpty() => GetDataCount() == 0;
+
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <returns></returns>
+        public virtual int GetDataCount() => GetCollection().Count;
+    }
+}

package/ChapterSelectCollectionBase.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 509cf55ecda99624e808590ba1447dab