net.dreditor.progressing.handling 0.0.0-stage → 0.1.6

package/ProgressionHistoryManager.cs

@@ -0,0 +1,34 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+using DREditor.EventObjects;
+using DREditor.Saving;
+using UnityEngine;
+using UnityEngine.Scripting.APIUpdating;
+
+namespace DREditor.Progressing.Handling
+{
+    /// <summary>
+    ///
+    /// </summary>
+    [ClassHeader(nameof(HistoricalManagerBase<IHistory, ProgressionHistoryManager>) + " SERVICE for type: " + nameof(IHistory) +
+        "\n" + nameof(IDRESaveable) + ", " + nameof(IDRELoadableManager) + ", " + 
+        nameof(IDRELoadable) + ", " + nameof(ILoadOnChapterSelect) +
+        "\n\n")]
+    [MovedFrom(true, "DREditor.Progression.Handling", "DREditor.Progression.Handling")]
+    public class ProgressionHistoryManager : HistoricalManagerBase<IHistory, ProgressionHistoryManager>
+    {
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected IntWithEvent currentChapterIndex = null;
+
+
+        /// <inheritdoc/>
+        protected override object GetInstanceData()
+        {
+            historicalData.SetChapterIndex(currentChapterIndex.Value);
+
+            return base.GetInstanceData();
+        }
+    }
+}

package/ProgressionHistoryManager.cs.meta

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

package/ProgressionInfo.cs

@@ -0,0 +1,54 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Scripting.APIUpdating;
+
+namespace DREditor.Progressing.Handling
+{
+    /// <summary>
+    ///
+    /// </summary>
+    [System.Serializable]
+    [MovedFrom(true, "DREditor.Progression.Handling", "DREditor.Progression.Handling")]
+    public class ProgressionInfo
+    {
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        public List<Objective> objectives = new();
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="objectives"></param>
+        public virtual void SetObjectiveHistory(List<Objective> objectives) => this.objectives = objectives;
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="objective"></param>
+        public virtual void Add(Objective objective)
+        {
+            if (ContainsObjective(objective.Description))
+                return;
+
+            objectives.Add(objective);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="objectiveName"></param>
+        /// <returns></returns>
+        public virtual bool ContainsObjective(string objectiveName)
+        {
+            for (int i = 0; i < objectives.Count; i++)
+                if (objectives[i].Description == objectiveName)
+                    return true;
+
+            return false;
+        }
+    }
+}

package/ProgressionInfo.cs.meta

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

package/ProgressionLoader.cs

@@ -0,0 +1,129 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+using DREditor.EventObjects;
+using DREditor.Saving;
+using DREditor.Services;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Scripting.APIUpdating;
+using UnityEngine.Serialization;
+
+namespace DREditor.Progressing.Handling
+{
+    /// <summary>
+    ///
+    /// </summary>
+    [ClassHeader(nameof(SceneEventListener) + ", " + nameof(IDRELoadable) +
+        "\n\n")]
+    [MovedFrom(true, "DREditor.Progression.Handling", "DREditor.Progression.Handling")]
+    public class ProgressionLoader : SceneEventListener, IDRELoadable
+    {
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [FormerlySerializedAs("database")]
+        [SerializeField] protected ProgressionDatabase progressionDatabase = null;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected IntWithEvent currentChapterIndex = null;
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Header("")]
+        [Divider]
+        [Tooltip("")]
+        [SerializeField] protected string chapterKey = "chapter";
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected string objectiveKey = "CurrentObjective";
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected Dictionary<string, object> saveDatas;
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected ProgressionManagerBase manager = null;
+
+
+
+        protected virtual void Start() => manager = ServiceLocator.GetService<ProgressionManagerBase>();
+
+
+        /// <inheritdoc/>
+        public virtual void Load(Dictionary<string, object> saveDatas) => this.saveDatas = saveDatas;
+
+        /// <inheritdoc/>
+        protected override void OnResponseInvoked()
+        {
+            base.OnResponseInvoked();
+
+            LoadOnSceneEvent();
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void LoadOnSceneEvent()
+        {
+            currentChapterIndex.SetValue(saveDatas.Get<int>(chapterKey));
+
+            manager.SetCurrentChapter(progressionDatabase.Chapters[currentChapterIndex.Value]);
+
+
+            Objective saveObjective = saveDatas.Get<Objective>(objectiveKey);
+
+            manager.SetCurrentObjective(saveObjective);
+
+
+            LoadBaseObjective(saveObjective);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="saveObjective"></param>
+        protected void LoadBaseObjective(Objective saveObjective)
+        {
+            Objective baseObjective = progressionDatabase.GetObjective(manager.currentObjective.Description);
+
+            if (baseObjective == null)
+            {
+                UnityEngine.Debug.LogWarning($"REPORT: {ToString()}: " +
+                    $"Attempting to Repair the Objective since it's not found in any chapter.");
+
+                int finishedObjectives = ServiceLocator.GetService<IHistory>().GetAmountOfFinishedObjectives();
+
+                baseObjective = progressionDatabase
+                    .GetObjective(progressionDatabase.Chapters[currentChapterIndex.Value].Objectives[finishedObjectives].Description);
+
+                manager.ResetCurrentObjective(baseObjective, saveObjective);
+            }
+            else if (saveObjective.KeepInstanceData != baseObjective.KeepInstanceData || FlagCountUpdated(baseObjective, saveObjective))
+                manager.ResetCurrentObjective(baseObjective, saveObjective);
+
+            if (baseObjective != null && baseObjective.ProgressionGate != null)
+                manager.currentObjective.SetProgressionGate(baseObjective.ProgressionGate);
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="baseObjective"></param>
+        /// <param name="saveObjective"></param>
+        /// <returns></returns>
+        protected virtual bool FlagCountUpdated(Objective baseObjective, Objective saveObjective) =>
+            baseObjective.Description == saveObjective.Description && baseObjective.Flags.Count != saveObjective.Flags.Count;
+    }
+}

package/ProgressionLoader.cs.meta

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

package/ProgressionManager.cs

@@ -0,0 +1,286 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+using DREditor.EventObjects;
+using DREditor.Services;
+using UnityEngine;
+using UnityEngine.Scripting.APIUpdating;
+
+namespace DREditor.Progressing.Handling
+{
+    /// <summary>
+    ///
+    /// </summary>
+    [ClassHeader(nameof(ServiceHolder<ProgressionManagerBase>) + " for type: " + nameof(ProgressionManagerBase) +
+        "\n\n")]
+    [MovedFrom(true, "DREditor.Progression.Handling", "DREditor.Progression.Handling")]
+    public class ProgressionManager : ProgressionManagerBase
+    {
+        /// <summary>
+        ///
+        /// </summary>
+        [Header("")]
+        [Divider]
+        [Tooltip("")]
+        [SerializeField] protected IntWithEvent currentChapterIndex = null;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected IntWithEvent currentObjectiveIndex = null;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected BoolWithEvent onLastObjective = null;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected BoolWithEvent objectiveKeepsInstanceData = null;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected BoolWithEvent requiredFlagsTriggered = null;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected StringWithEvent currentObjectiveName = null;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected StringWithEvent moveToObjective = null;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected SceneEventListener newGameSelected = null;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected SceneEventListener startedNewGame = null;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected SceneEventListener moveToNextNaturalObjective = null;
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void OnEnable() => SubscribeToEvents();
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void OnDisable() => UnsubscribeToEvents();
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void SubscribeToEvents()
+        {
+            moveToNextNaturalObjective.Response.AddListener(MoveToNextNaturalObjective);
+
+            newGameSelected.Response.AddListener(ResetProgression);
+
+            startedNewGame.Response.AddListener(ResetProgression);
+
+            moveToObjective.AddListener(MoveToObjective);
+
+            currentChapterIndex.AddListener(SetCurrentChapterByIndex);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void UnsubscribeToEvents()
+        {
+            moveToNextNaturalObjective.Response.RemoveListener(MoveToNextNaturalObjective);
+
+            newGameSelected.Response.RemoveListener(ResetProgression);
+
+            startedNewGame.Response.RemoveListener(ResetProgression);
+
+            moveToObjective.RemoveListener(MoveToObjective);
+
+            currentChapterIndex.RemoveListener(SetCurrentChapterByIndex);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="index"></param>
+        /// <remarks>
+        ///
+        /// </remarks>
+        protected virtual void SetCurrentChapterByIndex(int index) => SetCurrentChapter(progressionDatabase.Chapters[index]);
+
+        /// <inheritdoc/>
+        public override bool PassedPoint(int chapter, string objectiveName)
+        {
+            if (currentChapterIndex.Value > chapter)
+                return true;
+
+            if (currentChapterIndex.Value < chapter)
+                return false;
+
+            return ServiceLocator.GetService<IHistory>().ContainsObjective(objectiveName);
+        }
+
+        /// <inheritdoc/>
+        public override void SetCurrentChapter(Chapter chapter)
+        {
+            base.SetCurrentChapter(chapter);
+
+            currentChapterIndex.SetValue(progressionDatabase.Chapters.IndexOf(chapter));
+
+            UnityEngine.Debug.Log($"REPORT: {nameof(ProgressionManager)}: The Chapter index has changed to {chapter}.");
+        }
+
+        /// <inheritdoc/>
+        public override void SetCurrentObjective(Objective objective)
+        {
+            base.SetCurrentObjective(objective);
+
+            bool isFinalObjective = currentObjective.Description == currentChapter.Objectives[^1].Description;
+
+            onLastObjective.SetValue(isFinalObjective);
+
+            currentObjectiveIndex.SetValue(currentChapter.Objectives.IndexOf(currentObjective));
+
+            currentObjectiveName.SetValue(currentObjective.Description);
+
+            objectiveKeepsInstanceData.SetValue(progressionDatabase.GetObjective(currentObjective.Description).KeepInstanceData);
+
+            requiredFlagsTriggered.SetValue(false);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void ResetProgression()
+        {
+            SetCurrentChapter(progressionDatabase.Chapters[0]);
+
+            currentChapterIndex.SetValue(0);
+
+            SetCurrentObjective((Objective)currentChapter.Objectives[0].Clone());
+
+            ServiceLocator.GetService<IHistory>().Clear();
+
+            UnityEngine.Debug.Log($"REPORT: {nameof(ProgressionManager)}: Progression Reset.");
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="objective"></param>
+        /// <returns></returns>
+        protected virtual Objective GetNextObjective(Objective objective)
+        {
+            for (int i = 0; i < currentChapter.Objectives.Count; i++)
+            {
+                Objective iteratedObjective = currentChapter.Objectives[i];
+
+                if (iteratedObjective.Description == objective.Description)
+                {
+                    if (i + 1 < currentChapter.Objectives.Count)
+                        return currentChapter.Objectives[i + 1];
+                    else
+                    {
+                        MoveToNextChapter();
+
+                        return currentChapter.Objectives[0];
+                    }
+                }
+            }
+
+            UnityEngine.Debug.Log($"REPORT: {ToString()}: GetNextObjective Evaluated Null");
+
+            return null;
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void MoveToNextChapter()
+        {
+            for (int i = 0; i < progressionDatabase.Chapters.Count; i++)
+                if (progressionDatabase.Chapters[i] == currentChapter && (i + 1) < progressionDatabase.Chapters.Count)
+                    SetCurrentChapter(progressionDatabase.Chapters[i + 1]);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="objectiveName"></param>
+        protected virtual void MoveToObjective(string objectiveName)
+        {
+            if (string.IsNullOrEmpty(objectiveName))
+                return;
+
+            ServiceLocator.GetService<IHistory>().Add(currentChapterIndex.Value, currentObjective);
+
+            Objective objective = progressionDatabase.GetObjective(objectiveName);
+
+            if (objective == null)
+            {
+                UnityEngine.Debug.LogError($"ALERT: {ToString()}: " +
+                    $"The Move to Objective called name does not match any valid objectives, " +
+                    $"for: " + objectiveName + " . Please make sure the string is spelled correctly and has correct case.");
+
+                return;
+            }
+            else
+            {
+                ServiceLocator.GetService<IHistory>().SetPreviousObjective((Objective)currentObjective.Clone());
+
+                SetCurrentObjective((Objective)objective.Clone());
+            }
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void MoveToNextNaturalObjective()
+        {
+            bool isFTEObjective = currentChapter.GetObjective(currentObjective.Description) == null;
+
+            if (isFTEObjective)
+                SetCurrentObjective((Objective)GetNextObjective(ServiceLocator.GetService<IHistory>().GetLastObjective()).Clone());
+            else
+                ChangeObjective();
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void ChangeObjective()
+        {
+            UnityEngine.Debug.Log($"REPORT: {nameof(ProgressionManager)}: Changing objective from current objective: " 
+                + currentObjective.Description);
+
+            ServiceLocator.GetService<IHistory>().Add(currentChapterIndex.Value, currentObjective);
+
+            string overrideFlagObjectiveName = currentObjective.GetOverrideFlag();
+
+            if (!string.IsNullOrEmpty(overrideFlagObjectiveName))
+                SetCurrentObjective((Objective)progressionDatabase.GetObjective(overrideFlagObjectiveName).Clone());
+            else
+                SetCurrentObjective((Objective)GetNextObjective(currentObjective).Clone());
+        }
+    }
+}

package/ProgressionManager.cs.meta

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

package/ProgressionManagerBase.cs

@@ -0,0 +1,132 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+using DREditor.Services;
+using UnityEngine;
+using UnityEngine.Scripting.APIUpdating;
+using UnityEngine.Serialization;
+
+namespace DREditor.Progressing.Handling
+{
+    /// <summary>
+    ///
+    /// </summary>
+    [MovedFrom(true, "DREditor.Progression.Handling", "DREditor.Progression.Handling")]
+    public abstract class ProgressionManagerBase : ServiceHolder<ProgressionManagerBase>
+    {
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [FormerlySerializedAs("database")]
+        [SerializeField] protected ProgressionDatabase progressionDatabase = null;
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Header("")]
+        [Divider]
+        [Tooltip("")]
+        [SerializeField] protected Chapter currentChapter = null;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        public Objective currentObjective = null;
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void Start()
+        {
+            InitializeCurrentChapter();
+
+            CleanChapterAsset();
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void InitializeCurrentChapter()
+        {
+            if (CurrentChapterCanBeAssigned())
+                currentChapter = progressionDatabase.Chapters[0];
+            else
+                UnityEngine.Debug.LogError("ALERT: You must have a valid progression database with a chapter and objective assigned!");
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <returns></returns>
+        protected virtual bool CurrentChapterCanBeAssigned() =>
+            progressionDatabase != null && progressionDatabase.Chapters.Count > 0 && progressionDatabase.Chapters[0] != null && currentChapter == null;
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void CleanChapterAsset()
+        {
+            if (currentChapter == null)
+                return;
+
+            foreach (Objective objective in currentChapter.Objectives)
+                foreach (ProgressionFlag flag in objective.Flags)
+                    flag.SetTriggered(false);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <returns></returns>
+        public virtual Chapter GetCurrentChapter() => currentChapter;
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="chapter"></param>
+        /// <param name="objectiveName"></param>
+        /// <returns></returns>
+        public abstract bool PassedPoint(int chapter, string objectiveName);
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="chapter"></param>
+        public virtual void SetCurrentChapter(Chapter chapter) => currentChapter = chapter;
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="objective"></param>
+        /// <remarks>
+        ///
+        /// </remarks>
+        public virtual void SetCurrentObjective(Objective objective) => currentObjective = (Objective)objective.Clone();
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="baseObjective"></param>
+        /// <param name="saveObjective"></param>
+        /// <remarks></remarks>
+        public virtual void ResetCurrentObjective(Objective baseObjective, Objective saveObjective)
+        {
+            SetCurrentObjective((Objective)baseObjective.Clone());
+
+            CopyFlagTriggers(saveObjective);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="saveObjective"></param>
+        /// <remarks></remarks>
+        protected virtual void CopyFlagTriggers(Objective saveObjective)
+        {
+            for (int i = 0; i < saveObjective.Flags.Count && i < currentObjective.Flags.Count; i++)
+                currentObjective.Flags[i].SetTriggered(saveObjective.Flags[i].triggered);
+        }
+    }
+}