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

package/IHistory.cs

@@ -0,0 +1,101 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+using DREditor.Saving;
+using System.Collections.Generic;
+using UnityEngine.Scripting.APIUpdating;
+
+namespace DREditor.Progressing.Handling
+{
+    /// <summary>
+    ///
+    /// </summary>
+    [MovedFrom(true, "DREditor.Progression.Handling", "DREditor.Progression.Handling")]
+    public interface IHistory : IPersistentData, IClearableOnNewGameSelected
+    {
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="chapterIndex"></param>
+        /// <param name="objective"></param>
+        void Add(int chapterIndex, Objective objective);
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="objectiveName"></param>
+        /// <returns></returns>
+        bool ContainsObjective(string objectiveName);
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <returns></returns>
+        int GetAmountOfFinishedObjectives();
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <returns></returns>
+        List<List<Objective>> GetChapterHistory();
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="flagName"></param>
+        /// <returns></returns>
+        ProgressionFlag GetFlagFromHistory(string flagName);
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="chapter"></param>
+        /// <param name="objective"></param>
+        /// <param name="flag"></param>
+        /// <returns></returns>
+        ProgressionFlag GetFlagFromIndexes(int chapter, int objective, int flag);
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="chapter"></param>
+        /// <param name="objective"></param>
+        /// <returns></returns>
+        Objective GetHistoryObjective(int chapter, int objective);
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <returns></returns>
+        Objective GetLastObjective();
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="chapterHistory"></param>
+        void SetChapterHistory(List<List<Objective>> chapterHistory);
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="chapter"></param>
+        void SetChapterIndex(int chapter);
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="objective"></param>
+        void SetPreviousObjective(Objective objective);
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="selectedChapter"></param>
+        /// <returns></returns>
+        int GetObjectiveCountFromHistory(int selectedChapter);
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <returns></returns>
+        int LatestChapterIndex();
+    }
+}

package/IHistory.cs.meta

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

package/ProgressionData.cs

@@ -0,0 +1,181 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine;
+using UnityEngine.Scripting.APIUpdating;
+using UnityEngine.Serialization;
+
+namespace DREditor.Progressing.Handling
+{
+    /// <summary>
+    ///
+    /// </summary>
+    [Serializable]
+    [MovedFrom(true, "DREditor.Progression.Handling", "DREditor.Progression.Handling")]
+    public class ProgressionData : IHistory
+    {
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        public int chapter;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        public Objective previousObjective;
+
+
+        /// <remarks></remarks>
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [FormerlySerializedAs("Info")]
+        public List<ProgressionInfo> Infos = new();
+
+        public ProgressionData() { }
+
+        /// <inheritdoc/>
+        public virtual void CarryOver(IPersistentData persistentData)
+        {
+            if (persistentData is ProgressionData oldData)
+                Infos = oldData.Infos;
+            else
+                UnityEngine.Debug.LogWarning("ALERT: TRIED TO SET PROGRESSION DATA OF A DIFFERENT TYPE!");
+        }
+
+        /// <inheritdoc/>
+        public virtual void SetChapterIndex(int chapter) => this.chapter = chapter;
+
+
+        /// <inheritdoc/>
+        public virtual void SetPreviousObjective(Objective objective) => previousObjective = objective;
+
+        /// <inheritdoc/>
+        public virtual void Add(int chapterIndex, Objective objective)
+        {
+            RecursiveAdd(chapterIndex);
+
+            Infos[chapterIndex].Add(objective);
+        }
+
+        protected virtual void RecursiveAdd(int chapterIndex)
+        {
+            if (chapterIndex >= Infos.Count)
+            {
+                Infos.Add(new ProgressionInfo());
+
+                RecursiveAdd(chapterIndex);
+            }
+        }
+
+        /// <inheritdoc/>
+        public virtual void Clear() => Infos.Clear();
+
+        /// <inheritdoc/>
+        public virtual Objective GetLastObjective()
+        {
+            if (previousObjective != null)
+                return previousObjective;
+
+            if (Infos.Count == 0)
+                return null;
+
+            return Infos.Last().objectives.Last();
+        }
+
+        /// <inheritdoc/>
+        public virtual bool ContainsObjective(string objectiveName)
+        {
+            for (int i = 0; i < Infos.Count; i++)
+                if (Infos[i].ContainsObjective(objectiveName))
+                    return true;
+
+            return false;
+        }
+
+        /// <inheritdoc/>
+        public virtual ProgressionFlag GetFlagFromHistory(string flagName)
+        {
+            IEnumerable<ProgressionInfo> chaptersContainingFlag =
+                Infos.Where(chapter => chapter.objectives.Where(objective => objective.GetFlagNames()
+                .Contains(flagName)).Count() > 0);
+
+            if (chaptersContainingFlag.Count() > 0)
+            {
+                var firstObjectiveContainingFlag =
+                    chaptersContainingFlag.ElementAt(0).objectives.Where(n => n.GetFlagNames().Contains(flagName)).ElementAt(0);
+
+                var matchingFlags = firstObjectiveContainingFlag.Flags.Where(n => n.name == flagName);
+
+                if (matchingFlags.Count() > 0 && matchingFlags.ElementAt(0) != null)
+                    return matchingFlags.ElementAt(0);
+            }
+
+            UnityEngine.Debug.LogWarning("After Checking this save files previously completed Objectives, " +
+                    "that flag couldn't be found. \n" +
+                "Which means one has occured: There's been user error building progression, " +
+                "The Searched progression flag string used was misspelt, OR the save file never completed or had the objective " +
+                "that contained the searched flag. \n" +
+                "If you still encounter this error after making sure Debug Viewing " +
+                "Progression data contains the flag, and the searched flag " +
+                "was not misspelt, you should contact Sweden in order to debug and find the problem.");
+
+            return null;
+        }
+
+        /// <inheritdoc/>
+        public virtual List<List<Objective>> GetChapterHistory()
+        {
+            List<List<Objective>> chapterHistory = new();
+
+            foreach (var chapter in Infos)
+                chapterHistory.Add(chapter.objectives);
+
+            return chapterHistory;
+        }
+
+        /// <inheritdoc/>
+        public virtual void SetChapterHistory(List<List<Objective>> chapterHistory)
+        {
+            foreach (var chapter in Infos)
+                chapter.SetObjectiveHistory(chapterHistory[Infos.IndexOf(chapter)]);
+        }
+
+        /// <inheritdoc/>
+        public virtual Objective GetHistoryObjective(int chapter, int objective) => Infos[chapter].objectives[objective];
+
+        /// <inheritdoc/>
+        public virtual int GetAmountOfFinishedObjectives()
+            => Infos.Count > chapter ? Infos[chapter].objectives.Count : 0;
+
+        /// <inheritdoc/>
+        public virtual int GetObjectiveCountFromHistory(int selectedChapter)
+        {
+            if (selectedChapter < Infos.Count && selectedChapter >= 0)
+                return Infos[selectedChapter].objectives.Count;
+
+            UnityEngine.Debug.LogWarning($"REPORT: The selected chapter index: {selectedChapter} " +
+                $"does not have progression history! Is there Progression data missing?");
+
+            return 0;
+        }
+
+        /// <inheritdoc/>
+        public virtual int LatestChapterIndex()
+        {
+            int history = Infos.Count;
+
+            --history;
+
+            return Math.Max(chapter, history);
+        }
+
+        /// <inheritdoc/>
+        public virtual ProgressionFlag GetFlagFromIndexes(int chapter, int objective, int flag)
+            => GetHistoryObjective(chapter, objective).Flags[flag];
+    }
+}

package/ProgressionData.cs.meta

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

package/ProgressionDebugger.cs

@@ -0,0 +1,186 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+using DREditor.EventObjects;
+using DREditor.Services;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Scripting.APIUpdating;
+using UnityEngine.Serialization;
+
+namespace DREditor.Progressing.Handling
+{
+    /// <summary>
+    ///
+    /// </summary>
+    [DefaultExecutionOrder(1)]
+	[ClassHeader("")]
+    [MovedFrom(true, "DREditor.Progression.Handling", "DREditor.Progression.Handling")]
+    public class ProgressionDebugger : MonoBehaviour
+    {
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [FormerlySerializedAs("database")]
+        [SerializeField] protected ProgressionDatabase progressionDatabase = null;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected IntWithEvent currentChapterIndex = null;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected SceneEventListener onGeneratePastData = null;
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Header("")]
+        [Divider]
+        [Tooltip("")]
+        [SerializeField] protected bool testLatestObjective = false;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected int startObjective = 0;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected int clearedFlags = 0;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected bool generatePastData = false;
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected ProgressionManagerBase manager = null;
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void OnEnable() => onGeneratePastData.Response.AddListener(GeneratePast);
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void OnDisable() => onGeneratePastData.Response.RemoveListener(GeneratePast);
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void Start() => Initialize();
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void Initialize()
+        {
+            manager = ServiceLocator.GetService<ProgressionManagerBase>();
+
+            InitializeStartObjective();
+
+            TriggerFlagsInCurrentObjective();
+
+            InitializePastData();
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void InitializeStartObjective()
+        {
+            if (manager == null)
+                manager = ServiceLocator.GetService<ProgressionManagerBase>();
+
+            if (manager.GetCurrentChapter() == null)
+                return;
+
+            startObjective = testLatestObjective ? manager.GetCurrentChapter().Objectives.Count - 1 : startObjective;
+
+            if (manager.GetCurrentChapter().Objectives.Count > 0)
+                manager.SetCurrentObjective((Objective)manager.GetCurrentChapter().Objectives[startObjective].Clone());
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void TriggerFlagsInCurrentObjective()
+        {
+            if (manager.currentObjective != null && clearedFlags > 0 && clearedFlags <= manager.currentObjective.Flags.Count)
+                for (int i = 0; i < clearedFlags; i++)
+                    manager.currentObjective.Flags[i].SetTriggered(true);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void InitializePastData()
+        {
+            if (generatePastData)
+                GeneratePast();
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void GeneratePast()
+        {
+            for (int chapterIndex = 0; chapterIndex <= currentChapterIndex.Value; chapterIndex++)
+                GenerateChapterObjectives(chapterIndex);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="chapterIndex"></param>
+        protected void GenerateChapterObjectives(int chapterIndex)
+        {
+            foreach (Objective objective in progressionDatabase.Chapters[chapterIndex].Objectives)
+            {
+                if (objective.Description == manager.currentObjective.Description)
+                    break;
+
+                GenerateCompletedObjectiveToHistory(chapterIndex, objective);
+            }
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="chapterIndex"></param>
+        /// <param name="objective"></param>
+        protected void GenerateCompletedObjectiveToHistory(int chapterIndex, Objective objective)
+        {
+            Objective clonedObjective = (Objective)objective.Clone();
+
+            TriggerAllRequiredFlags(clonedObjective.Flags);
+
+            ServiceLocator.GetService<IHistory>().Add(chapterIndex, clonedObjective);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="flags"></param>
+        protected void TriggerAllRequiredFlags(List<ProgressionFlag> flags)
+        {
+            foreach (ProgressionFlag flag in flags)
+                if (!flag.optional)
+                    flag.SetTriggered(true);
+        }
+    }
+}

package/ProgressionDebugger.cs.meta

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

package/ProgressionFlagHandler.cs

@@ -0,0 +1,167 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+using DREditor.Services;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Scripting.APIUpdating;
+using UnityEngine.Serialization;
+
+namespace DREditor.Progressing.Handling
+{
+    /// <summary>
+    ///
+    /// </summary>
+	[ClassHeader("")]
+    [MovedFrom(true, "DREditor.Progression.Handling", "DREditor.Progression.Handling")]
+    public class ProgressionFlagHandler : MonoBehaviour
+    {
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [FormerlySerializedAs("database")]
+        [SerializeField] protected ProgressionDatabase progressionDatabase = null;
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="flagName"></param>
+        /// <param name="targetObjective"></param>
+        /// <returns></returns>
+        public virtual ProgressionFlag GetFlag(string flagName, Objective targetObjective)
+        {
+            if (SearchCurrentObjective(flagName, targetObjective) is ProgressionFlag flagOne && flagOne != null)
+                return flagOne;
+
+
+            RepairProgressionHistory(ServiceLocator.GetService<IHistory>().GetChapterHistory());
+
+            if (ServiceLocator.GetService<IHistory>().GetFlagFromHistory(flagName) is ProgressionFlag flagTwo && flagTwo != null)
+                return flagTwo;
+
+
+            RepairObjective(ref targetObjective);
+
+            if (SearchCurrentObjective(flagName, targetObjective) is ProgressionFlag flagThree && flagThree != null)
+                return flagThree;
+
+
+            return OnFlagNotRevived(flagName);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="chapterHistory"></param>
+        protected virtual void RepairProgressionHistory(List<List<Objective>> chapterHistory)
+        {
+            UnityEngine.Debug.Log($"REPORT: {ToString()}: Repairing progression history.");
+
+            foreach (List<Objective> chapterObjectives in chapterHistory)
+                RepairObjectivesOnFlagMismatch(chapterObjectives);
+
+            ServiceLocator.GetService<IHistory>().SetChapterHistory(chapterHistory);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="objectives"></param>
+        protected virtual void RepairObjectivesOnFlagMismatch(List<Objective> objectives)
+        {
+            for (int i = 0; i < objectives.Count; i++)
+                RepairObjectiveOnFlagMismatch(objectives[i]);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="objective"></param>
+        protected virtual void RepairObjectiveOnFlagMismatch(Objective objective)
+        {
+            if (ObjectiveFlagsDontMatchBase(objective))
+                RepairObjective(ref objective);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="objective"></param>
+        /// <returns></returns>
+        protected virtual bool ObjectiveFlagsDontMatchBase(Objective objective)
+            => objective.Flags.Count != progressionDatabase.GetObjective(objective.Description).Flags.Count;
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="flagName"></param>
+        /// <returns></returns>
+        protected virtual ProgressionFlag OnFlagNotRevived(string flagName)
+        {
+            UnityEngine.Debug.LogWarning("ALERT: After repairing the current save file objective, the current " +
+                "flag couldn't be found. Best to contact Sweden for support.");
+
+            UnityEngine.Debug.LogWarning("ALERT: Since the flag couldn't be found for Flag: " + flagName +
+                " the game will just return a triggered flag and use that as the default.");
+
+            return new ProgressionFlag(true);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="objective"></param>
+        public virtual void RepairObjective(ref Objective objective)
+        {
+            UnityEngine.Debug.LogWarning("REPORT: The system noticed an issue with the current objective and will now repair it." +
+                "\nThis is common in scenarios where objective data from a save file is outdated or manipulated through debugging.");
+
+            Objective currentObjectiveCopy = (Objective)objective.Clone();
+
+            objective = (Objective)progressionDatabase.GetObjective(objective.Description).Clone();
+
+            CopyFlagsToObjective(currentObjectiveCopy, ref objective);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="currentObjectiveCopy"></param>
+        /// <param name="targetObjective"></param>
+        protected virtual void CopyFlagsToObjective(Objective currentObjectiveCopy, ref Objective targetObjective)
+        {
+            for (int i = 0; i < currentObjectiveCopy.Flags.Count; i++)
+                ApplyFlagStateToObjectivesFlag(currentObjectiveCopy.Flags[i], ref targetObjective);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="originalFlag"></param>
+        /// <param name="targetObjective"></param>
+        protected virtual void ApplyFlagStateToObjectivesFlag(ProgressionFlag originalFlag, ref Objective targetObjective)
+        {
+            foreach (ProgressionFlag currentObjectiveFlag in targetObjective.Flags)
+                if (currentObjectiveFlag.name == originalFlag.name && originalFlag.triggered)
+                    currentObjectiveFlag.SetTriggered(true);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="flagName"></param>
+        /// <param name="currentObjective"></param>
+        /// <returns></returns>
+        protected virtual ProgressionFlag SearchCurrentObjective(string flagName, Objective currentObjective)
+        {
+            foreach (ProgressionFlag flag in currentObjective.Flags)
+                if (flag.name == flagName)
+                    return flag;
+
+            UnityEngine.Debug.LogWarning("ALERT: Flag: " + flagName + " could not be found on Objective: " + 
+                currentObjective.Description + " Make sure you spell the flag name correctly!");
+
+            return null;
+        }
+    }
+}

package/ProgressionFlagHandler.cs.meta

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