AppleHillsProduction/Assets/Editor/Dialogue/DialogueNodes.cs

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();
        }
    }
    
    [Serializable]
    public class WaitOnCombination : DialogueNode
    {
        const string RequiredResultItemOptionName = "RequiredResultItem";
        
        protected override void OnDefinePorts(IPortDefinitionContext context)
        {
            context.AddInputPort<PickupItemData>(RequiredResultItemOptionName).WithDisplayName("Required Result Item").Build();
            
            base.OnDefinePorts(context);
        }
    }
}