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

package/ChapterTitleDisplayer.cs

@@ -0,0 +1,42 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+using DREditor.EventObjects;
+using DREditor.Services;
+using TMPro;
+using UnityEngine;
+using UnityEngine.Scripting.APIUpdating;
+
+namespace DREditor.Progressing.Handling
+{
+    /// <summary>
+    ///
+    /// </summary>
+	[ClassHeader("")]
+    [MovedFrom(true, "DREditor.Progression.Handling", "DREditor.Progression.Handling")]
+    public class ChapterTitleDisplayer : MonoBehaviour
+    {
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected IntWithEvent currentChapterIndex = null;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected TextMeshProUGUI title = null;
+
+
+        protected virtual void OnEnable() => currentChapterIndex.AddListener(UpdateTitle);
+
+        protected virtual void OnDisable() => currentChapterIndex.RemoveListener(UpdateTitle);
+        
+        protected virtual void Start() => UpdateTitle();
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void UpdateTitle(int index = 0) 
+            => title.text = ServiceLocator.GetService<ProgressionManagerBase>().GetCurrentChapter().title;
+    }
+}

package/ChapterTitleDisplayer.cs.meta

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

package/DREditor.Progressing.Handling.asmdef

@@ -0,0 +1,17 @@
+{
+    "name": "DREditor.Progressing.Handling",
+    "rootNamespace": "",
+    "references": [
+        "Unity.TextMeshPro",
+        "DREditor"
+    ],
+    "includePlatforms": [],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
+}

package/DREditor.Progressing.Handling.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: ad666efc806c0494b8de19a3eac53e09
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/FlagTriggerExtensions.cs

@@ -0,0 +1,79 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+using DREditor.Dialogues;
+using DREditor.Services;
+using UnityEngine.Scripting.APIUpdating;
+
+namespace DREditor.Progressing.Handling
+{
+    /// <summary>
+    ///
+    /// </summary>
+    [MovedFrom(true, "DREditor.Progression.Handling", "DREditor.Progression.Handling")]
+    public static class FlagTriggerExtensions
+    {
+        // If Particle Progression is working normally this code can be deleted.
+        //public static bool ContainsFlagTriggerFor(this Dialogue dialogue, int chap, int objName)
+        //{
+        //    if (dialogue.FlagTrigger != null &&
+        //        dialogue.FlagTrigger.Enabled && 
+        //        dialogue.FlagTrigger.Objective == objName &&
+        //        dialogue.FlagTrigger.Chapter == chap)
+        //        return true;
+        //    else if (dialogue != null && dialogue.DirectTo != null && dialogue.DirectTo.Enabled)
+        //        return dialogue.DirectTo.NewDialogue.ContainsFlagTriggerFor(chap, objName);
+
+        //    return false;
+        //}
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="dialogue"></param>
+        /// <returns></returns>
+        public static bool HasUnTriggeredRequiredFlags<T>(this DialogueBase<T> dialogue)
+        {
+            if (dialogue != null && dialogue.FlagTrigger != null && dialogue.FlagTrigger.Enabled)
+                foreach (var index in dialogue.FlagTrigger.Flags)
+                    if (HasUnTriggeredRequiredFlag(dialogue, index))
+                        return true;
+
+            return false;
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="dialogue"></param>
+        /// <param name="index"></param>
+        /// <returns></returns>
+        public static bool HasUnTriggeredRequiredFlag<T>(DialogueBase<T> dialogue, int index)
+        {
+            if (!dialogue.FlagTrigger.FlagIsOptional(index) && !dialogue.FlagTrigger.FlagHasBeenTriggered(index))
+                return true;
+            else if (dialogue.DirectTo != null && dialogue.DirectTo.Enabled)
+                return dialogue.DirectTo.NewDialogue.HasUnTriggeredRequiredFlags();
+
+            return false;
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="trigger"></param>
+        /// <param name="flagIndex"></param>
+        /// <returns></returns>
+        public static bool FlagHasBeenTriggered(this TriggerFlag trigger, int flagIndex)
+        => ServiceLocator.GetService<FlagTriggerHandlerBase>()
+            .GetFlagFromIndexes(trigger.Chapter, trigger.Objective, flagIndex).triggered;
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="trigger"></param>
+        /// <param name="flagIndex"></param>
+        /// <returns></returns>
+        public static bool FlagIsOptional(this TriggerFlag trigger, int flagIndex)
+            => ServiceLocator.GetService<FlagTriggerHandlerBase>()
+            .GetFlagFromIndexes(trigger.Chapter, trigger.Objective, flagIndex).optional;
+    }
+}

package/FlagTriggerExtensions.cs.meta

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

package/FlagTriggerHandler.cs

@@ -0,0 +1,237 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+using DREditor.EventObjects;
+using DREditor.Services;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Scripting.APIUpdating;
+using UnityEngine.Serialization;
+
+namespace DREditor.Progressing.Handling
+{
+    /// <summary>
+    ///
+    /// </summary>
+    [ClassHeader(nameof(FlagTriggerHandlerBase) +
+        "\n\n")]
+    [MovedFrom(true, "DREditor.Progression.Handling", "DREditor.Progression.Handling")]
+    public class FlagTriggerHandler : FlagTriggerHandlerBase
+    {
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [FormerlySerializedAs("database")]
+        [SerializeField] protected ProgressionDatabase progressionDatabase = null;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected ProgressionFlagHandler flagHandler = null;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected IntWithEvent currentChapterIndex = null;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected StringWithEvent flagTriggered = null;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected BoolWithEvent requiredFlagsTriggered = null;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected SceneEventListener loadProgressionData = null;
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected ProgressionManagerBase manager = null;
+
+        protected virtual void OnEnable() => loadProgressionData.Response.AddListener(Load);
+
+        protected virtual void OnDisable() => loadProgressionData.Response.RemoveListener(Load);
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void Load() => StartCoroutine(DelayLoad());
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <remarks>
+        ///
+        /// </remarks>
+        protected virtual IEnumerator DelayLoad()
+        {
+            yield return null;
+
+            requiredFlagsTriggered.SetValue(CompletedRequiredFlags());
+        }
+
+
+        protected virtual void Start() => manager = ServiceLocator.GetService<ProgressionManagerBase>();
+
+        /// <inheritdoc/>
+        public override void TriggerFlag(int chapterIndex, int objectiveIndex, List<int> flagIndexes)
+        {
+            try
+            {
+                bool onCurrentChapter = chapterIndex == currentChapterIndex.Value;
+
+                Objective targetObjective = progressionDatabase.Chapters[chapterIndex].Objectives[objectiveIndex];
+
+                bool targetIsCurrentObjective = targetObjective.Description == manager.currentObjective.Description;
+
+                if (onCurrentChapter && targetIsCurrentObjective)
+                    TriggerFlagsInCurrentObjective(flagIndexes);
+                else
+                    TriggerFlagsInHistory(chapterIndex, objectiveIndex, flagIndexes);
+            }
+            catch (Exception exception)
+            {
+                UnityEngine.Debug.LogWarning("ALERT: A CRITICAL ERROR HAS OCCURED TRIGGERING A PROGRESSION FLAG " +
+                    "\n PLEASE CHECK THE DIALOGUE ASSET TO FIX OR FIND THE ISSUE.");
+
+                UnityEngine.Debug.LogWarning(exception);
+            }
+        }
+
+        public override void TriggerFlag(List<int> flagIndexes)
+        {
+            var activeObjective = progressionDatabase.Chapters[currentChapterIndex.Value].GetObjective(manager.currentObjective.Description);
+
+            int objectiveIndex = progressionDatabase.Chapters[currentChapterIndex.Value].Objectives.IndexOf(activeObjective);
+
+            TriggerFlag(currentChapterIndex.Value, objectiveIndex, flagIndexes);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="flagIndexes"></param>
+        protected virtual void TriggerFlagsInCurrentObjective(List<int> flagIndexes)
+        {
+            Objective objective = manager.currentObjective;
+
+            for (int i = 0; i < flagIndexes.Count; i++)
+            {
+                if (flagIndexes[i] > objective.Flags.Count)
+                {
+                    flagHandler.RepairObjective(ref manager.currentObjective);
+
+                    objective = manager.currentObjective;
+                }
+
+                objective.Flags[flagIndexes[i]].SetTriggered(true);
+
+                flagTriggered.SetValue(objective.Flags[flagIndexes[i]].name);
+
+                requiredFlagsTriggered.SetValue(CompletedRequiredFlags());
+            }
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="chapterIndex"></param>
+        /// <param name="objectiveIndex"></param>
+        /// <param name="flagIndexes"></param>
+        protected virtual void TriggerFlagsInHistory(int chapterIndex, int objectiveIndex, List<int> flagIndexes)
+        {
+            Objective targetObjective = progressionDatabase.Chapters[chapterIndex].Objectives[objectiveIndex];
+
+            for (int i = 0; i < flagIndexes.Count; i++)
+                flagHandler.GetFlag(targetObjective.Flags[flagIndexes[i]].name, targetObjective).SetTriggered(true);
+        }
+
+        /// <inheritdoc/>
+        public override bool IsFlagTriggered(string flagName) => flagHandler.GetFlag(flagName, manager.currentObjective).triggered;
+
+        /// <inheritdoc/>
+        public override bool EvaluateVariable(int chapter, int objective, List<int> flags, List<int> falseFlags = null)
+        {
+            bool checkingCurrentObjective =
+                progressionDatabase.Chapters[chapter].Objectives[objective].Description == manager.currentObjective.Description;
+
+            Objective evaluateObjective = checkingCurrentObjective ?
+                manager.currentObjective : ServiceLocator.GetService<IHistory>().GetHistoryObjective(chapter, objective);
+
+            return EvaluateVariableFlags(evaluateObjective, flags, falseFlags);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="objective"></param>
+        /// <param name="flags"></param>
+        /// <param name="falseFlags"></param>
+        /// <returns></returns>
+        protected virtual bool EvaluateVariableFlags(Objective objective, List<int> flags, List<int> falseFlags = null)
+        {
+            for (int i = 0; i < flags.Count; i++)
+                if (!objective.Flags[flags[i]].triggered)
+                    return false;
+
+            if (falseFlags != null)
+                for (int i = 0; i < falseFlags.Count; i++)
+                    if (objective.Flags[falseFlags[i]].triggered)
+                        return false;
+
+            return true;
+        }
+
+        /// <inheritdoc/>
+        public override void TriggerAllRequiredFlags()
+        {
+            List<int> flagIndexes = new();
+
+            for (int i = 0; i < manager.currentObjective.Flags.Count; i++)
+                if (!manager.currentObjective.Flags[i].optional && !manager.currentObjective.Flags[i].triggered)
+                    flagIndexes.Add(i);
+
+            TriggerFlag(flagIndexes);
+        }
+
+        /// <inheritdoc/>
+        protected override bool CompletedRequiredFlags()
+        {
+            int check = 0;
+
+            foreach (ProgressionFlag flag in manager.currentObjective.Flags)
+                if (flag.triggered && !flag.optional)
+                    check++;
+
+            return check == manager.currentObjective.GetRequiredFlagCount();
+        }
+
+        /// <inheritdoc/>
+        public override ProgressionFlag GetFlagFromIndexes(int chapter, int objective, int flag)
+        {
+            bool onCurrentChapter = chapter == currentChapterIndex.Value;
+
+            string sentObjectiveName = progressionDatabase.Chapters[currentChapterIndex.Value].Objectives[objective].Description;
+
+            bool onCurrentObjective = sentObjectiveName == manager.currentObjective.Description;
+
+            if (onCurrentChapter && onCurrentObjective)
+                return manager.currentObjective.Flags[flag];
+            else
+                return ServiceLocator.GetService<IHistory>().GetFlagFromIndexes(chapter, objective, flag);
+        }
+    }
+}

package/FlagTriggerHandler.cs.meta

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

package/FlagTriggerHandlerBase.cs

@@ -0,0 +1,66 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+using DREditor.Services;
+using System.Collections.Generic;
+using UnityEngine.Scripting.APIUpdating;
+
+namespace DREditor.Progressing.Handling
+{
+    /// <summary>
+    ///
+    /// </summary>
+    [MovedFrom(true, "DREditor.Progression.Handling", "DREditor.Progression.Handling")]
+    public abstract class FlagTriggerHandlerBase : ServiceHolder<FlagTriggerHandlerBase>
+    {
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="chapterIndex"></param>
+        /// <param name="objectiveIndex"></param>
+        /// <param name="flagIndexes"></param>
+        public abstract void TriggerFlag(int chapterIndex, int objectiveIndex, List<int> flagIndexes);
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="flagIndexes"></param>
+        public abstract void TriggerFlag(List<int> flagIndexes);
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="flagName"></param>
+        /// <returns></returns>
+        public abstract bool IsFlagTriggered(string flagName);
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="chapter"></param>
+        /// <param name="objective"></param>
+        /// <param name="flags"></param>
+        /// <param name="falseFlags"></param>
+        /// <returns></returns>
+        public abstract bool EvaluateVariable(int chapter, int objective, List<int> flags, List<int> falseFlags = null);
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <returns></returns>
+        protected abstract bool CompletedRequiredFlags();
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="chapter"></param>
+        /// <param name="objective"></param>
+        /// <param name="flag"></param>
+        /// <returns></returns>
+        public abstract ProgressionFlag GetFlagFromIndexes(int chapter, int objective, int flag);
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <remarks></remarks>
+        public abstract void TriggerAllRequiredFlags();
+    }
+}

package/FlagTriggerHandlerBase.cs.meta

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

package/HistoricalManagerBase.cs

@@ -0,0 +1,159 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+using DREditor.EventObjects;
+using DREditor.Saving;
+using DREditor.Services;
+using DREditor.Utility;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Scripting.APIUpdating;
+
+namespace DREditor.Progressing.Handling
+{
+    /// <summary>
+    ///
+    /// </summary>
+    [MovedFrom(true, "DREditor.Progression.Handling", "DREditor.Progression.Handling")]
+    public abstract class HistoricalManagerBase<T, T2> : ServiceHolder<T2>,
+        IDRESaveable, IDRELoadableManager, IDRELoadable, ILoadOnChapterSelect
+        where T2 : class
+    {
+        /// <summary>
+        ///
+        /// </summary>
+        [Header("")]
+        [Divider]
+        [Tooltip("")]
+        [SerializeField] protected SceneEventListener loadProgressionData = null;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected SceneEventListener newGameSelected = null;
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Header("")]
+        [Divider]
+        [Tooltip("")]
+        [SerializeField] protected string progressionKey = "ProgressionData";
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SelectType]
+        [SerializeReference] protected T historicalData;
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected Dictionary<string, object> saveDatas;
+
+
+        protected override void InitializeService()
+        {
+            base.InitializeService();
+
+            if (ServiceLocator.HasService(out T2 activeManager) && this as T2 == activeManager)
+                ServiceLocator.Register<T>(historicalData);
+        }
+
+        protected override void OnDestroy()
+        {
+            base.OnDestroy();
+
+            if (ServiceLocator.HasService(out T activeHistory) && activeHistory.Equals(historicalData))
+                ServiceLocator.Unregister<T>(historicalData);
+        }
+
+
+        public virtual void Load(Dictionary<string, object> saveDatas) => this.saveDatas = saveDatas;
+
+
+        protected virtual void OnEnable()
+        {
+            loadProgressionData.AddListener(OnLoadProgressionDataInvoked);
+
+            newGameSelected.AddListener(OnNewGameSelected);
+        }
+
+        protected virtual void OnDisable()
+        {
+            loadProgressionData.RemoveListener(OnLoadProgressionDataInvoked);
+
+            newGameSelected.RemoveListener(OnNewGameSelected);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void OnLoadProgressionDataInvoked() => LoadRegisterData(GetSaveData(saveDatas));
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <returns></returns>
+        protected virtual T GetSaveData(Dictionary<string, object> saveDatas) =>
+            (T)saveDatas.GetGeneric(progressionKey, historicalData.GetType());
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void OnNewGameSelected()
+        {
+            if (ServiceLocator.GetService<T>() is IClearableOnNewGameSelected clearable)
+                clearable?.Clear();
+        }
+
+
+        public virtual void Save(Dictionary<string, object> saveDatas) =>
+            saveDatas.Set(progressionKey, GetInstanceData());
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <returns></returns>
+        protected virtual object GetInstanceData() => historicalData;
+
+
+        public virtual void LoadManager(Dictionary<string, object> saveDatas, bool inChapterSelect) =>
+            LoadRegisterData(GetSaveData(saveDatas).DeepCopy());
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="historicalData"></param>
+        protected virtual void LoadRegisterData(T historicalData)
+        {
+            if (historicalData == null)
+                return;
+
+            ServiceLocator.Unregister<T>();
+
+            this.historicalData = historicalData;
+
+            ServiceLocator.Register<T>(this.historicalData);
+        }
+
+
+        public virtual void CarryOverOnChapterSelect(Dictionary<string, object> oldSaveDatas, Dictionary<string, object> newSaveDatas)
+        {
+            if (GetSaveData(oldSaveDatas) is IPersistentData loadedData && GetSaveData(newSaveDatas) is IPersistentData newData)
+                newData?.CarryOver(loadedData);
+            else
+                OnCarryingOverFailed(oldSaveDatas, newSaveDatas);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="oldSaveDatas"></param>
+        /// <param name="newSaveDatas"></param>
+        protected virtual void OnCarryingOverFailed(Dictionary<string, object> oldSaveDatas, Dictionary<string, object> newSaveDatas) =>
+            UnityEngine.Debug.LogWarning($"ANALYSIS: Either the new or loaded progression data were not of type: {nameof(IPersistentData)}.");
+    }
+}

package/HistoricalManagerBase.cs.meta

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