DialogueGraphNode.h

Go to the documentation of this file.

// Copyright Csaba Molnar, Daniel Butum. All Rights Reserved.
#pragma once
 
#include "CoreTypes.h"
#include "UObject/ObjectMacros.h"
 
#include "Nodes/DlgNode_End.h"
#include "Nodes/DlgNode_Speech.h"
#include "Nodes/DlgNode_Selector.h"
#include "Nodes/DlgNode_SpeechSequence.h"
#include "DialogueGraphNode_Base.h"
 
#include "DialogueGraphNode.generated.h"
 
class UEdGraphPin;
class DialogueGraphNode_Edge;
class UToolMenu;
class UGraphNodeContextMenuContext;
 
struct FDiffNodeEdgeLinkedToPinResult
{
    enum EDiffType
    {
        NO_DIFFERENCE = 0,
 
        // A result of DoesEdgeMatchEdgeIndex
        EDGE_NOT_MATCHING_INDEX,
 
        // The length of the arrays mismatch, there is one more edge (located at the end) than pin connection
        LENGTH_MISMATCH_ONE_MORE_EDGE,
 
        // The length of the arrays mismatch, there is one more pin connection (located at the end) than edges
        LENGTH_MISMATCH_ONE_MORE_PIN_CONNECTION,
 
        // Diff type not supported
        NOT_SUPPORTED
    };
 
    EDiffType Type = EDiffType::NO_DIFFERENCE;
 
    int32 Index = INDEX_NONE;
 
    FString Message;
};
 
UCLASS()
class UDialogueGraphNode : public UDialogueGraphNode_Base
{
    GENERATED_BODY()
 
public:
    //
    // Begin UObject Interface.
    //
 
    void PostLoad() override;
 
    void PostEditImport() override;
 
    void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) override;
 
    void PostEditChangeChainProperty(struct FPropertyChangedChainEvent& PropertyChangedEvent) override;
 
    bool Modify(bool bAlwaysMarkDirty = true) override;
 
    //
    // Begin UEdGraphNode interface
    //
 
    FText GetNodeTitle(ENodeTitleType::Type TitleType) const override;
 
    FText GetTooltipText() const override;
    FString GetDocumentationExcerptName() const override;
 
    bool CanDuplicateNode() const override { return !IsRootNode(); }
 
    bool CanUserDeleteNode() const override { return !IsRootNode(); }
 
    void PrepareForCopying() override;
 
    void NodeConnectionListChanged() override
    {
        CheckDialogueNodeSyncWithGraphNode(true);
        ApplyCompilerWarnings();
    }
 
    void PinConnectionListChanged(UEdGraphPin* Pin) override;
 
#if ENGINE_MINOR_VERSION >= 24
    void GetNodeContextMenuActions(UToolMenu* Menu, UGraphNodeContextMenuContext* Context) const override;
#else
    void GetContextMenuActions(const FGraphNodeContextMenuBuilder& Context) const override;
#endif
 
    void AutowireNewNode(UEdGraphPin* FromPin) override;
 
    // Begin UDialogueGraphNode_Base interface
 
    bool CanHaveInputConnections() const override { return NodeIndex != INDEX_NONE && !IsRootNode(); }
 
    bool CanHaveOutputConnections() const override { return !IsEndNode(); }
 
    bool HasOutputConnectionToNode(const UEdGraphNode* TargetNode) const override;
 
    FLinearColor GetNodeBackgroundColor() const override;
 
    void PostCopyNode() override;
 
    void CheckAll() const override
    {
#if DO_CHECK
        Super::CheckAll();
        check(IsDialogueNodeSet());
        CheckDialogueNodeIndexMatchesNode();
        CheckDialogueNodeSyncWithGraphNode(true);
#endif
    }
 
    virtual bool IsRootNode() const { return false; }
 
    //
    // Begin own functions
    //
 
    bool IsEndNode() const { return DialogueNode->IsA<UDlgNode_End>(); }
 
    bool IsSpeechNode() const { return DialogueNode->IsA<UDlgNode_Speech>(); }
 
    bool IsVirtualParentNode() const
    {
        if (const UDlgNode_Speech* Node = Cast<UDlgNode_Speech>(DialogueNode))
        {
            return Node->IsVirtualParent();
        }
 
        return false;
    }
 
    bool IsSelectorNode() const { return DialogueNode->IsA<UDlgNode_Selector>(); }
 
    bool IsSelectorFirstNode() const
    {
        if (const UDlgNode_Selector* Node = Cast<UDlgNode_Selector>(DialogueNode))
        {
            return Node->GetSelectorType() == EDlgNodeSelectorType::First;
        }
 
        return false;
    }
 
    bool IsSelectorRandomNode() const
    {
        if (const UDlgNode_Selector* Node = Cast<UDlgNode_Selector>(DialogueNode))
        {
            return Node->GetSelectorType() == EDlgNodeSelectorType::Random;
        }
 
        return false;
    }
 
    bool IsSpeechSequenceNode() const { return DialogueNode->IsA<UDlgNode_SpeechSequence>(); }
 
    bool HasEnterConditions() const
    {
        return DialogueNode ? DialogueNode->HasAnyEnterConditions() : false;
    }
 
    bool HasEnterEvents() const
    {
        return DialogueNode ? DialogueNode->HasAnyEnterEvents() : false;
    }
 
    bool HasVoicePropertiesSet() const;
 
    bool HasGenericDataSet() const;
 
    int32 GetNodeDepth() const { return NodeDepth; }
 
    void SetNodeDepth(int32 NewNodeDepth) { NodeDepth = NewNodeDepth; }
 
    virtual void SetDialogueNode(UDlgNode* InNode)
    {
        DialogueNode = InNode;
        DialogueNode->SetFlags(RF_Transactional);
        DialogueNode->SetGraphNode(this);
        RegisterListeners();
    }
 
    virtual void SetDialogueNodeIndex(int32 InIndex)
    {
        check(InIndex > INDEX_NONE);
        NodeIndex = InIndex;
    }
 
    // Where should the edges pointing to this node be positioned at
    // NOTE: we use this because otherwise the edges don't get rendered
    FIntPoint GetDefaultEdgePosition() const { return GetPosition() + FIntPoint(5, 5); }
 
 
    void SetDialogueNodeDataChecked(int32 InIndex, UDlgNode* InNode);
 
    template <typename DlgNodeType>
    const DlgNodeType& GetDialogueNode() const { return *CastChecked<DlgNodeType>(DialogueNode); }
 
    template <typename DlgNodeType>
    DlgNodeType* GetMutableDialogueNode() { return CastChecked<DlgNodeType>(DialogueNode); }
 
    // Specialization for the methods above  (by overloading) for the base type UDlgNode type so that we do not need to cast
    const UDlgNode& GetDialogueNode() const { return *DialogueNode; }
    UDlgNode* GetMutableDialogueNode() const { return DialogueNode; }
 
    bool IsDialogueNodeSet() const { return DialogueNode != nullptr; }
 
    virtual int32 GetDialogueNodeIndex() const { return NodeIndex; }
 
    int32 GetChildEdgeIndexForChildNodeIndex(int32 ChildNodeIndex) const;
 
    void SetEdgeTargetIndexAt(int32 EdgeIndex, int32 NewTargetIndex);
 
    void SetEdgeTextAt(int32 EdgeIndex, const FText& NewText);
 
    // Sets all the node children (edges).
    // NOTE: USE WITH CAUTION
    void SetEdges(const TArray<FDlgEdge>& InEdges);
 
    // Updates the edges data from the DialogueNode
    // NOTE: USE WITH CAUTION
    void UpdateEdgesFromDialogueNode();
 
    void ApplyCompilerWarnings();
 
    int32 EstimateNodeWidth() const;
 
    void CheckDialogueNodeIndexMatchesNode() const;
 
    void CheckDialogueNodeSyncWithGraphNode(bool bStrictCheck = false) const;
 
    TArray<UDialogueGraphNode*> GetParentNodes() const;
 
    TArray<UDialogueGraphNode*> GetChildNodes() const;
 
    TArray<UDialogueGraphNode_Edge*> GetParentEdgeNodes(bool bCheckChild = true) const;
 
    TArray<UDialogueGraphNode_Edge*> GetChildEdgeNodes(bool bCheckParent = true) const;
 
    bool HasChildEdgeNode(const UDialogueGraphNode_Edge* ChildEdgeToFind) const;
 
    bool HasParentEdgeNode(const UDialogueGraphNode_Edge* ParentEdgeToFind) const;
 
    void SortChildrenBasedOnXLocation();
 
    bool GetForceHideNode() const { return bForceHideNode; }
 
    void SetForceHideNode(bool bHide) { bForceHideNode = bHide; }
 
    bool ShouldDrawNode() const { return !bForceHideNode; }
 
    static FName GetMemberNameDialogueNode() { return GET_MEMBER_NAME_CHECKED(UDialogueGraphNode, DialogueNode); }
    static FName GetMemberNameNodeIndex() { return GET_MEMBER_NAME_CHECKED(UDialogueGraphNode, NodeIndex); }
 
protected:
    // Begin UDialogueGraphNode_Base interface
    virtual void CreateInputPin()
    {
        static const FName PinName(TEXT("Input Pin"));
        FCreatePinParams PinParams;
        PinParams.Index = INDEX_PIN_Input;
        CreatePin(EGPD_Input, UDialogueGraphSchema::PIN_CATEGORY_Input, PinName, PinParams);
    }
 
    virtual void CreateOutputPin()
    {
        static const FName PinName(TEXT("Output Pin"));
        FCreatePinParams PinParams;
        PinParams.Index = INDEX_PIN_Output;
        CreatePin(EGPD_Output, UDialogueGraphSchema::PIN_CATEGORY_Output, PinName, PinParams);
 
        // This enables or disables dragging of the pin from the Node, see SGraphPin::OnPinMouseDown for details
        GetOutputPin()->bNotConnectable = IsEndNode();
    }
 
    void RegisterListeners() override;
 
    //
    // Begin own functions
    //
 
    void OnDialogueNodePropertyChanged(const FPropertyChangedEvent& PropertyChangedEvent, int32 EdgeIndexChanged);
 
    void ResetDialogueNodeOwner();
 
private:
    const FDiffNodeEdgeLinkedToPinResult FindDifferenceBetweenNodeEdgesAndLinkedToPins() const;
 
    bool DoesEdgeMatchEdgeIndex(const FDlgEdge& Edge, int32 EdgeIndex, FString& OutMessage) const;
 
protected:
    UPROPERTY(EditAnywhere, Instanced, Category = DialogueGraphNode, Meta = (ShowOnlyInnerProperties))
    UDlgNode* DialogueNode;
 
    UPROPERTY(VisibleAnywhere, Category = DialogueGraphNode)
    int32 NodeIndex = INDEX_NONE;
 
    // Indicates the distance from the start node. This is only set after the graph is compiled.
    UPROPERTY()
    int32 NodeDepth = INDEX_NONE;
 
    bool bForceHideNode = false;
};