Introduced dialogue graph magic, created assest and importers. Added events for broadcasting puzzle steps

Assets/Editor/Dialogue/DialogueNodes.cs

@@ -0,0 +1,196 @@
+using UnityEngine;
+using Unity.GraphToolkit.Editor;
+using System;
+
+namespace Editor.Dialogue
+{
+    [Serializable]
+    public class StartNode : Node
+    {
+        protected override void OnDefinePorts(IPortDefinitionContext context)
+        {
+            context.AddOutputPort("out").Build();
+            
+            context.AddInputPort<string>("SpeakerName").Build();
+        }
+    }
+    
+    [Serializable]
+    public class EndNode : Node
+    {
+        protected override void OnDefinePorts(IPortDefinitionContext context)
+        {
+            context.AddInputPort("in").Build();
+        }
+    }
+    
+    [Serializable]
+    public enum DialogueType
+    {
+        SayOneLine,
+        SayMultipleLines
+    }
+    
+    [Serializable]
+    public class DialogueNode : Node 
+    {
+        const string LineTypeOptionName = "DialogueLineType";
+        const string NoLinesOptionName = "NoLines";
+        const string LoopThroughDefaultLinesOptionName = "LoopThroughDefaultLines";
+        const string DefaultDialogueLineOptionName = "DefaultDialogueLine";
+        
+        
+        protected override void OnDefineOptions(IOptionDefinitionContext context)
+        {
+            context.AddOption<DialogueType>(LineTypeOptionName)
+                .WithDisplayName("Default Line Type")
+                .WithDefaultValue(DialogueType.SayOneLine)
+                .Delayed();
+
+
+            context.AddOption<int>(NoLinesOptionName)
+                .WithDisplayName("Number of Default Lines")
+                .WithDefaultValue(1)
+                .Delayed();
+        }
+
+        protected override void OnDefinePorts(IPortDefinitionContext context)
+        {
+            context.AddInputPort("in").Build();
+            context.AddOutputPort("out").Build();
+            
+            var lineTypeOption = GetNodeOptionByName(LineTypeOptionName);
+            lineTypeOption.TryGetValue<DialogueType>(out var lineType);
+            var lineCountOption = GetNodeOptionByName(NoLinesOptionName);
+            lineCountOption.TryGetValue<int>(out var lineCount);
+
+            if (lineType == DialogueType.SayMultipleLines)
+            {
+                for (var i = 0; i < lineCount; i++)
+                {
+                    context.AddInputPort<string>($"{DefaultDialogueLineOptionName}{i + 1}").WithDisplayName($"Default Dialogue Line {i + 1}").Build();
+                }
+            }
+            else
+            {
+                context.AddInputPort<string>($"{DefaultDialogueLineOptionName}").WithDisplayName("Default Dialogue Line").Build();
+            }
+            
+            context.AddInputPort<bool>($"{LoopThroughDefaultLinesOptionName}").WithDisplayName("Loop Through Default Lines?").Build();
+        }
+    }
+
+    [Serializable]
+    public class WaitOnPuzzleStep : DialogueNode
+    {
+        const string RequiredPuzzleStep = "RequiredPuzzleStep";
+        
+        protected override void OnDefinePorts(IPortDefinitionContext context)
+        {
+            context.AddInputPort<PuzzleStepSO>(RequiredPuzzleStep).WithDisplayName("Required Puzzle Step").Build();
+            
+            base.OnDefinePorts(context);
+        }
+    }
+    
+    [Serializable]
+    public class WaitOnPickup : DialogueNode
+    {
+        const string RequiredPickupsOptionName = "RequiredPickup";
+        
+        protected override void OnDefinePorts(IPortDefinitionContext context)
+        {
+            context.AddInputPort<PickupItemData>(RequiredPickupsOptionName).WithDisplayName("Required Pickup").Build();
+            
+            base.OnDefinePorts(context);
+        }
+    }
+    
+    [Serializable]
+    public class WaitOnSlot : DialogueNode
+    {
+        const string RequiredSlotOptionName = "RequiredSlot";
+        // Incorrect item - i.e. not the correct one but also not forbidden
+        const string IncorrectItemLineTypeOptionName = "IncorrectItemDialogueLineType";
+        const string IncorrectItemNoLinesOptionName = "IncorrectItemNoLines";
+        const string LoopThroughIncorrectItemLinesOptionName = "LoopThroughIncorrectItemLines";
+        const string IncorrectIteDialogueLineOptionName = "IncorrectItemDialogueLine";
+        // Explicitely forbidden item
+        const string ForbiddenItemLineTypeOptionName = "ForbiddenItemDialogueLineType";
+        const string ForbiddenItemNoLinesOptionName = "ForbiddenItemNoLines";
+        const string LoopThroughForbiddenItemLinesOptionName = "LoopThroughForbiddenItemLines";
+        const string ForbiddenIteDialogueLineOptionName = "ForbiddenItemDialogueLine";
+        
+        protected override void OnDefineOptions(IOptionDefinitionContext context)
+        {
+            base.OnDefineOptions(context);
+            
+            // Incorrect
+            context.AddOption<DialogueType>(IncorrectItemLineTypeOptionName)
+                .WithDisplayName("Incorrect Item Line Type")
+                .WithDefaultValue(DialogueType.SayOneLine)
+                .Delayed();
+            context.AddOption<int>(IncorrectItemNoLinesOptionName)
+                .WithDisplayName("Number of Incorrect Item Lines")
+                .WithDefaultValue(1)
+                .Delayed();
+            
+            // Forbidden
+            context.AddOption<DialogueType>(ForbiddenItemLineTypeOptionName)
+                .WithDisplayName("Forbidden Item Line Type")
+                .WithDefaultValue(DialogueType.SayOneLine)
+                .Delayed();
+            context.AddOption<int>(ForbiddenItemNoLinesOptionName)
+                .WithDisplayName("Forbidden of Incorrect Item Lines")
+                .WithDefaultValue(1)
+                .Delayed();
+        }
+        
+        protected override void OnDefinePorts(IPortDefinitionContext context)
+        {
+            context.AddInputPort<PickupItemData>(RequiredSlotOptionName).WithDisplayName("Required Slot").Build();
+            
+            base.OnDefinePorts(context);
+            
+            // Incorrect
+            var incorrectItemLineTypeOption = GetNodeOptionByName(IncorrectItemLineTypeOptionName);
+            incorrectItemLineTypeOption.TryGetValue<DialogueType>(out var incorrectItemLineType);
+            var incorrectItemLineCountOption = GetNodeOptionByName(IncorrectItemNoLinesOptionName);
+            incorrectItemLineCountOption.TryGetValue<int>(out var incorrectItemLineCount);
+
+            if (incorrectItemLineType == DialogueType.SayMultipleLines)
+            {
+                for (var i = 0; i < incorrectItemLineCount; i++)
+                {
+                    context.AddInputPort<string>($"{IncorrectIteDialogueLineOptionName}{i + 1}").WithDisplayName($"Incorrect Item Dialogue Line {i + 1}").Build();
+                }
+            }
+            else
+            {
+                context.AddInputPort<string>($"{IncorrectIteDialogueLineOptionName}").WithDisplayName("Incorrect Item Dialogue Line").Build();
+            }
+            
+            context.AddInputPort<bool>($"{LoopThroughIncorrectItemLinesOptionName}").WithDisplayName("Loop Through Incorrect Item Lines?").Build();
+            
+            // Forbidden
+            var forbiddenItemLineTypeOption = GetNodeOptionByName(ForbiddenItemLineTypeOptionName);
+            forbiddenItemLineTypeOption.TryGetValue<DialogueType>(out var forbiddenItemLineType);
+            var forbiddenItemLineCountOption = GetNodeOptionByName(ForbiddenItemNoLinesOptionName);
+            forbiddenItemLineCountOption.TryGetValue<int>(out var forbiddenItemLineCount);
+
+            if (forbiddenItemLineType == DialogueType.SayMultipleLines)
+            {
+                for (var i = 0; i < forbiddenItemLineCount; i++)
+                {
+                    context.AddInputPort<string>($"{ForbiddenIteDialogueLineOptionName}{i + 1}").WithDisplayName($"Forbidden Item Dialogue Line {i + 1}").Build();
+                }
+            }
+            else
+            {
+                context.AddInputPort<string>($"{ForbiddenIteDialogueLineOptionName}").WithDisplayName("Forbidden Item Dialogue Line").Build();
+            }
+            
+            context.AddInputPort<bool>($"{LoopThroughForbiddenItemLinesOptionName}").WithDisplayName("Loop Through Forbidden Item Lines?").Build();
+        }
+    }
+}