added some stuff

Assets/Scripts/LemonGenericLib/DialogueSystem/DialogueSystem.cs

@@ -0,0 +1,404 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using TMPro;
+using System;
+using Lemon.GenericLib.Generics;
+
+//note
+//dialouge cannot be started in the start() call because it needs to wait for events
+namespace Lemon.GenericLib.Dialogue
+{
+    public class DialogueSystem : MonoBehaviour
+    {
+        [Header("dialogue configs")]
+        [SerializeField] private string[] dialougeTexts;
+        [SerializeField] private TextMeshProUGUI dialogueTextFeild;
+        [SerializeField] private static float typingSpeed = 50f;
+        private static float defaultTypingSpeed;
+        [SerializeField] Optional<string> interuptInput;
+        [SerializeField] Optional<string> advancingInput;
+        [SerializeField] private bool canUseExternalControls = true;
+        [SerializeField] public Color defaulrColour;
+
+        [Space]
+        [Header("timing configs")]
+        [SerializeField] private bool startImmediantly;
+        [SerializeField] public float startDelay;
+        [SerializeField] public float endDelay;
+
+        [Space]
+        [Header("command parsing configs")]
+        [SerializeField] private char commandPrefix;
+        [SerializeField] private bool skipEmpty;
+        [SerializeField] private char[] ignorePrefix;
+
+        [Space]
+        [Header("extra config ")]
+        [SerializeField] Optional<GameObject> continueButton;
+
+        public int SceneIndex;
+
+
+        public Action<string> dialogueCommandEvents;
+        public Action dialogueLineEvent;
+        public Action endDialougeEvents;
+        public Action dialogueStartEvents;
+
+        public Action initDialogueEvents;
+        public Action requiredEndEvent;
+
+        private int currentDialougeIndex = 0;
+        private bool isInterupt = false;
+        private bool isTyping = false;
+        public float waitTime = 0f;
+        public static bool doneSkipping = false;
+        //public DialogueLogger dialogueLogger;
+
+
+        // Start is called before the first frame update
+        IEnumerator Start()
+        {
+            dialogueTextFeild.text = "";
+            if (continueButton.Enabled)
+            {
+                continueButton.Value.SetActive(false);
+            }
+
+            //dialougeLineEvent += TestEvent;
+
+            if (startImmediantly)
+            {
+                yield return new WaitForSeconds(0.5f);
+                StartCoroutine(StartDialogueRoutine());
+            }
+
+            defaultTypingSpeed = typingSpeed;
+        }
+
+        // Update is called once per frame
+        void Update()
+        {
+            if (!canUseExternalControls) return;
+
+            HandleInputs();
+        }
+
+        bool isInputInterupt = false;
+        private void HandleInputs()
+        {
+            if (interuptInput.Enabled && isTyping)
+            {
+                if (Input.GetButtonDown(interuptInput.Value))
+                {
+                    //AudioManager2D.audioManager2DInstance.Play("UIClick");
+                    if (!isInterupt)
+                    {
+                        isInterupt = true;
+                    }
+                    return;
+                }
+            }
+
+            if (advancingInput.Enabled)
+            {
+                if (Input.GetButtonDown(advancingInput.Value))
+                {
+                    //AudioManager2D.audioManager2DInstance.Play("UIClick");
+                    if (!isTyping)
+                    {
+                        //Debug.Log(isTyping);
+                        AdvanceDialogue();
+                    }
+                    //else if (!isInterupt){
+                    //    isInputInterupt = true;
+                    //    isInterupt = true;
+                    //    StartCoroutine(resetInterupt());
+                    //}
+                    return;
+                }
+            }
+        }
+
+        public void LoadDialouge(string[] dialoguesToLoad, bool startImmediantly = true)
+        {
+
+            dialougeTexts = dialoguesToLoad;
+            dialogueStartEvents = null;
+            //endDialougeEvents = null;
+            if (startImmediantly)
+            {
+                StartDialogue();
+            }
+        }
+
+        public void StartDialogue()
+        {
+            if (dialougeTexts == null) return;
+            //AudioManager2D.audioManager2DInstance.Play("PageFlipSound");
+            StartCoroutine(StartDialogueRoutine());
+        }
+
+        IEnumerator StartDialogueRoutine()
+        {
+            initDialogueEvents?.Invoke();
+            dialogueTextFeild.color = defaulrColour;
+            yield return new WaitForSeconds(startDelay);
+            dialogueStartEvents?.Invoke();
+
+            currentDialougeIndex = 0;
+            TypeDialouge();
+        }
+
+        public void AdvanceDialogue()
+        {
+            //AudioManager2D.audioManager2DInstance.Play("ButtonSound");
+            if (!canUseExternalControls) return;
+            StopCoroutine("TypeDialougeRoutine");
+            if (dialougeTexts == null) return;
+
+            if (continueButton.Enabled)
+            {
+                continueButton.Value.SetActive(false);
+            }
+
+
+            currentDialougeIndex++;
+            Debug.LogWarning(currentDialougeIndex + ", " + dialougeTexts.Length);
+            if (currentDialougeIndex < dialougeTexts.Length)
+            {
+                TypeDialouge(dialougeTexts[currentDialougeIndex]);
+            }
+            else
+            {
+
+                if (continueButton.Enabled)
+                {
+                    continueButton.Value.SetActive(false);
+                }
+
+                StartCoroutine(EndDialogueRoutine());
+            }
+        }
+
+        public void SkipDialogue()
+        {
+            //isInterupt = true;
+            //currentDialougeIndex = dialougeTexts.Length;
+            //currentDialougeIndex++;
+            if (continueButton.Enabled)
+            {
+                continueButton.Value.SetActive(false);
+            }
+            AdvanceDialogue();
+        }
+
+        IEnumerator EndDialogueRoutine()
+        {
+            if (continueButton.Enabled)
+            {
+                continueButton.Value.SetActive(false);
+            }
+
+            requiredEndEvent?.Invoke();
+            dialogueTextFeild.text = "";
+            yield return new WaitForSeconds(endDelay);
+
+            //fire events
+            //endDialougeEvents?.Invoke();
+            //FindObjectOfType<SceneTransition>().GoToScene(SceneIndex);
+        }
+
+        public void SkipDialougeTyping()
+        {
+            StopCoroutine("TypeDialougeRoutine");
+            dialogueTextFeild.text = "";
+            AdvanceDialogue();
+        }
+
+        public void TypeDialouge()
+        {
+            StopCoroutine("typeDialougeRoutine");
+            StartCoroutine(TypeDialougeRoutine(dialougeTexts[currentDialougeIndex]));
+        }
+
+        public void TypeDialouge(string dialougeToType)
+        {
+            StopCoroutine("typeDialougeRoutine");
+            StartCoroutine(TypeDialougeRoutine(dialougeToType));
+        }
+
+        public void InteruptDialouge()
+        {
+            isInterupt = true;
+        }
+
+
+        public void SetStartEvents(Action[] events)
+        {
+            dialogueStartEvents = null;
+            foreach (var item in events)
+            {
+                dialogueStartEvents += item;
+            }
+
+        }
+
+        public void SetEndEvents(Action[] events)
+        {
+
+            endDialougeEvents = null;
+            foreach (var item in events)
+            {
+                endDialougeEvents += item;
+            }
+
+        }
+
+        //create a wait time vaiable that is public
+
+        IEnumerator TypeDialougeRoutine(string dialougeToType)
+        {
+
+
+            float t = 0;
+            int charIndex = 0;
+            isInterupt = false;
+
+            isTyping = true;
+
+            if (continueButton.Enabled)
+            {
+                continueButton.Value.SetActive(false);
+            }
+
+            Debug.Log(dialougeToType);
+            if (skipEmpty && (string.IsNullOrWhiteSpace(dialougeToType)))
+            {
+                SkipDialougeTyping();
+            }
+            else
+            {
+
+
+
+                dialogueCommandEvents?.Invoke(dialougeToType);
+                //make sure you can change wait time here woth the command fucntion
+
+
+
+                bool isSkipPrefix = false;
+
+                for (int i = 0; i < ignorePrefix.Length; i++)
+                {
+                    if (dialougeToType[0].Equals(ignorePrefix[i]))
+                    {
+                        isSkipPrefix = true;
+                    }
+                }
+
+                //Honestly have no idea where to put the wait so
+                if (waitTime > 0)
+                {
+                    yield return new WaitForSeconds(waitTime);
+                }
+                waitTime = 0;
+
+                Debug.Log($"shoud skip?: { dialougeToType[0] } {isSkipPrefix} ");
+                doneSkipping = false;
+                if (dialougeToType[0].Equals(commandPrefix) || isSkipPrefix)
+                {
+                    //wait even if wait time is 0
+                    //reset wait time after wait
+                    SkipDialougeTyping();
+                }
+                else
+                {
+                    //dialougeToType = dialougeTextEffects.UpdateText(dialougeToType);
+                    dialogueTextFeild.text = dialougeToType;
+
+                    //dialougeTextEffects.UpdateText(dialougeToType);
+
+                    //typing effect
+                    while (charIndex < dialougeToType.Length)
+                    {
+                        isTyping = true;
+                        //for whatever reason this needs to be in the loop to not show
+                        if (continueButton.Enabled)
+                        {
+                            continueButton.Value.SetActive(false);
+                        }
+
+                        if (isInterupt)
+                        {
+                            charIndex = dialougeToType.Length;
+                        }
+                        else
+                        {
+                            t += Time.deltaTime * typingSpeed;
+                            charIndex = Mathf.FloorToInt(t);
+                            charIndex = Mathf.Clamp(charIndex, 0, dialougeToType.Length);
+                        }
+
+                        //process here
+
+                        dialogueTextFeild.maxVisibleCharacters = charIndex;
+                        //dialogueTextFeild.text = dialougeToType.Substring(0, charIndex);
+
+                        yield return null;
+                    }
+                    doneSkipping = true;
+
+                    //dialogueLogger.AddToLog(dialougeToType, false, false);
+
+                    //dialogueTextFeild.text = dialougeToType;
+
+
+                }
+            }
+
+
+            isTyping = false;
+
+            //Fixes for continue button appearing when holding down skip
+            if (continueButton.Enabled)
+            {
+                if (doneSkipping == false)
+                {
+                    continueButton.Value.SetActive(false);
+                }
+                else
+                {
+                    continueButton.Value.SetActive(true);
+                }
+            }
+        }
+
+        IEnumerator resetInterupt()
+        {
+            yield return null;
+            isInputInterupt = false;
+
+        }
+
+        public void TestEvent(string testString)
+        {
+
+            Debug.Log(testString);
+            Debug.Log("Event is working as intended");
+        }
+
+        public static void setTypingSpeed(int newValue)
+        {
+            typingSpeed = newValue;
+        }
+
+        public static void setDefaultTypingSpeed()
+        {
+            typingSpeed = defaultTypingSpeed;
+        }
+
+    }
+
+}
+  

Assets/Scripts/LemonGenericLib/DialogueSystem/DialogueSystem.cs.meta

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