Create a new version of paste:

using System;
using UnityEditor;
using UnityEngine;

public class Node
{
    public Rect rect;
    public string title;

    public GUIStyle style;
    public GUIStyle defaultNodeStyle;
    public GUIStyle selectedNodeStyle;

    public bool isDragged;
    public bool isSelected;

    public ConnectionPoint inPoint;
    public ConnectionPoint outPoint;

    public Action<Node> OnRemoveNode;

    public ScenarioLeaf leaf;
    private string textToDisplay;

    public string scenarName;

    SerializedProperty CharacterShowingPrefab;
    SerializedProperty comment;
    SerializedProperty animationType;

    float heightLab;

    SerializedObject soTarget;

    public bool isLastOfRow;

    public Node(Vector2 position, float width, float height, GUIStyle nodeStyle, GUIStyle selectedStyle, GUIStyle inPointStyle, GUIStyle outPointStyle, Action<ConnectionPoint> OnClickInPoint, Action<ConnectionPoint> OnClickOutPoint, Action<Node> OnClickRemoveNode)
    {
        /*
         * Creates a Node without an existing leaf. Used when creating a new node.
         * Needs to add the leaf creating part.
         */
        rect = new Rect(position.x, position.y, width, height);
        style = nodeStyle;
        inPoint = new ConnectionPoint(this, ConnectionPointType.In, inPointStyle, OnClickInPoint);
        outPoint = new ConnectionPoint(this, ConnectionPointType.Out, outPointStyle, OnClickOutPoint);
        defaultNodeStyle = nodeStyle;
        selectedNodeStyle = selectedStyle;
        OnRemoveNode = OnClickRemoveNode;

    }
    public Node(Vector2 position, float width, float height, GUIStyle nodeStyle, GUIStyle selectedStyle, GUIStyle inPointStyle, GUIStyle outPointStyle, Action<ConnectionPoint> OnClickInPoint, Action<ConnectionPoint> OnClickOutPoint, Action<Node> OnClickRemoveNode, ScenarioLeaf leaf, string scenarName)
    {
        /*Creates a node with an existing leaf. Used when opening a scenario with this window.*/
        this.leaf = leaf;
        rect = new Rect(position.x, position.y, width, height);
        style = nodeStyle;
        inPoint = new ConnectionPoint(this, ConnectionPointType.In, inPointStyle, OnClickInPoint);
        outPoint = new ConnectionPoint(this, ConnectionPointType.Out, outPointStyle, OnClickOutPoint);
        defaultNodeStyle = nodeStyle;
        selectedNodeStyle = selectedStyle;
        OnRemoveNode = OnClickRemoveNode;

        soTarget = new SerializedObject(leaf);
        CharacterShowingPrefab = soTarget.FindProperty("CharacterShowingPrefab");
        comment = soTarget.FindProperty("comment");
        animationType = soTarget.FindProperty("animationType");
        this.scenarName = scenarName;
    }
    public Node(bool isLast, Vector2 position, float width, float height, GUIStyle nodeStyle, GUIStyle selectedStyle, GUIStyle inPointStyle, GUIStyle outPointStyle, Action<ConnectionPoint> OnClickInPoint, Action<ConnectionPoint> OnClickOutPoint, Action<Node> OnClickRemoveNode, ScenarioLeaf leaf, string scenarName)
    {
        /*Creates a node with an existing leaf. Used when opening a scenario with this window.*/
        this.leaf = leaf;
        rect = new Rect(position.x, position.y, width, height);
        style = nodeStyle;
        inPoint = new ConnectionPoint(this, ConnectionPointType.In, inPointStyle, OnClickInPoint);
        outPoint = new ConnectionPoint(this, ConnectionPointType.Out, outPointStyle, OnClickOutPoint);
        defaultNodeStyle = nodeStyle;
        selectedNodeStyle = selectedStyle;
        OnRemoveNode = OnClickRemoveNode;

        soTarget = new SerializedObject(leaf);
        CharacterShowingPrefab = soTarget.FindProperty("CharacterShowingPrefab");
        comment = soTarget.FindProperty("comment");
        animationType = soTarget.FindProperty("animationType");
        this.scenarName = scenarName;
        isLastOfRow = isLast;
    }
    public void Drag(Vector2 delta)
    {
        rect.position += delta;
    }
    public void Zoom(Vector2 delta)
    {
        /*rect.width += delta.x;
        rect.height += delta.y;*/
    }
    public void Draw()
    {
        GUIContent labelContent = new GUIContent(leaf.SimpleToString() + "\n(aka \"" + leaf.comment + "\")\n\n\n\n\n", leaf.ToString());
        GUIStyle labelStyle = new GUIStyle(style);
        labelStyle.alignment = TextAnchor.MiddleCenter;
        labelStyle.wordWrap = true;
        heightLab = labelStyle.CalcHeight(labelContent, rect.width - 20) + 18f;
        Rect labelRect = new Rect(rect.x, rect.y, rect.width + 10, heightLab);
        Rect CSPRect = new Rect(rect.x, rect.y + rect.height, rect.width, EditorGUIUtility.singleLineHeight);
        Rect AnimTypeRect = new Rect(CSPRect.x, CSPRect.y + CSPRect.height, CSPRect.width, EditorGUIUtility.singleLineHeight);
        Rect commentRect = new Rect(AnimTypeRect.x, AnimTypeRect.y + AnimTypeRect.height, AnimTypeRect.width, EditorGUIUtility.singleLineHeight);


        inPoint.Draw(heightLab);
        outPoint.Draw();
        //GUI.Box(labelRect, title, style);

        GUI.Label(labelRect, labelContent, labelStyle);
        EditorGUI.PropertyField(CSPRect, CharacterShowingPrefab);
        EditorGUI.PropertyField(AnimTypeRect, animationType);
        EditorGUI.PropertyField(commentRect, comment);
        soTarget.ApplyModifiedProperties();
    }

    public bool ProcessEvents(Event e)
    {
        switch (e.type)
        {
            case EventType.MouseDown:
                if (e.button == 0)
                {
                    if (rect.Contains(e.mousePosition))
                    {
                        if (e.clickCount == 1)
                        {
                            isDragged = true;
                            GUI.changed = true;
                            isSelected = true;
                            style = selectedNodeStyle;
                        }
                        else if (e.clickCount == 2)
                        {
                            isSelected = true;
                            style = selectedNodeStyle;
                            ActionsCW.Open(leaf, scenarName);
                            RequirementCW.Open(leaf, scenarName);
                        }

                    }
                    else
                    {
                        GUI.changed = true;
                        isSelected = false;
                        style = defaultNodeStyle;
                    }
                }
                if (e.button == 1 && isSelected && rect.Contains(e.mousePosition))
                {
                    ProcessContextMenu();
                    e.Use();
                }
                break;
            case EventType.MouseUp:
                isDragged = false;
                break;
            case EventType.MouseDrag:
                if (e.button == 0 && isDragged)
                {
                    Drag(e.delta);
                    e.Use();
                    return true;
                }
                break;
        }

        return false;
    }
    private void ProcessContextMenu()
    {
        GenericMenu genericMenu = new GenericMenu();
        genericMenu.AddItem(new GUIContent("Remove node"), false, OnClickRemoveNode);
        genericMenu.ShowAsContext();
    }

    private void OnClickRemoveNode()
    {
        if (OnRemoveNode != null)
        {
            OnRemoveNode(this);
        }
    }
}
############################################################ NODE EDITOR WINDOW ####################################################
using UnityEngine;
using UnityEditor;
using System.Collections.Generic;

public class NodeBasedEditor : EditorWindow
{
    private List<Node> nodes;
    private List<Connection> connections;

    private GUIStyle nodeStyle;
    private GUIStyle selectedNodeStyle;
    private GUIStyle inPointStyle;
    private GUIStyle outPointStyle;

    private ConnectionPoint selectedInPoint;
    private ConnectionPoint selectedOutPoint;

    private Vector2 offset;
    private Vector2 drag;

    private ScenarioTree treeInspecting;
    private SerializedObject treeSO;

    public float windowHeight { get => position.height; }
    public float windowWidth { get => position.width; }

    string pathToScenarFolder;
    string pathToLeaves;
    string pathToActions;
    string pathToReq;

    #region DrawingGraphs
    [MenuItem("Window/Node Based Editor")]
    public static void OpenWindow()
    {
        NodeBasedEditor window = GetWindow<NodeBasedEditor>();
        window.titleContent = new GUIContent("Node Based Editor");
    }
    public static void Open(ScenarioTree tree)
    {
        NodeBasedEditor window = GetWindow<NodeBasedEditor>();
        window.titleContent = new GUIContent("Node Based Editor");
        window.offset = new Vector2(100, 100);
        window.treeInspecting = tree;
        window.treeSO = new SerializedObject(tree);
        if (window.nodes != null) window.nodes.Clear();
        if (window.connections != null) window.connections.Clear();
        if (window.treeInspecting != null)
        {
            List<ScenarioLeaf> lastLeaves = new List<ScenarioLeaf>();
            foreach (ScenarioLeaf l in window.treeInspecting.Leaves)
            {
                #region old
                /*Node actualNode = window.AddNode(pos, l);
                pos.y -= 225;
                Here, maybe take some time to make sure we have a tree working for normal choices:
                - Using choices values in the order we made the choices
                - Using choices values exactly after the choice (?)
                Else, simply 
                 
                 //Change this by simply linking a leaf with it's next ones
                 well yeah but no
                 Do with with a foreach of the nodes
                 that's it
                if (l.nextLeaves != null)
                {
                    if(l.nextLeaves.Count > 0)
                    {
                        foreach (ScenarioLeaf NL in l.nextLeaves)
                        {

                        }
                        window.CreateConnection(previousNode, actualNode);
                    }
                }
                previousNode = actualNode;*/
                #endregion
                if (l.nextLeaves.Count == 0)    //Optimise?
                {
                    lastLeaves.Add(l);
                }
            }
            window.nodes = window.DrawTree(lastLeaves, 0);
            #region old
            /*
            foreach (Node n in window.nodes)
            {
                foreach (ScenarioLeaf NL in n.leaf.nextLeaves)
                {
                    foreach (Node childNode in window.nodes)
                    {
                        if(childNode.leaf == NL)//If this node's leaf is part of the "next leaves"'s list
                        {
                            window.CreateConnection(n, childNode);
                        }
                    }
                }
            }HAHAHAHHAHAHAHAH no.
            What we need here is some kind of recursive search...*/
            #endregion
        }
    }
    private void OnEnable()
    {
        nodeStyle = new GUIStyle();
        nodeStyle.normal.background = EditorGUIUtility.Load("builtin skins/darkskin/images/node1.png") as Texture2D;
        nodeStyle.border = new RectOffset(12, 12, 12, 12);

        selectedNodeStyle = new GUIStyle();
        selectedNodeStyle.normal.background = EditorGUIUtility.Load("builtin skins/darkskin/images/node1 on.png") as Texture2D;
        selectedNodeStyle.border = new RectOffset(12, 12, 12, 12);

        inPointStyle = new GUIStyle();
        inPointStyle.normal.background = EditorGUIUtility.Load("builtin skins/darkskin/images/btn act.png") as Texture2D;
        inPointStyle.active.background = EditorGUIUtility.Load("builtin skins/darkskin/images/btn act on.png") as Texture2D;
        inPointStyle.border = new RectOffset(4, 4, 12, 12);

        outPointStyle = new GUIStyle();
        outPointStyle.normal.background = EditorGUIUtility.Load("builtin skins/darkskin/images/btn act.png") as Texture2D;
        outPointStyle.active.background = EditorGUIUtility.Load("builtin skins/darkskin/images/btn act on.png") as Texture2D;
        outPointStyle.border = new RectOffset(4, 4, 12, 12);
    }
    private void OnGUI()
    {
        if (treeInspecting != null)
        {
            EditorGUILayout.LabelField("Scenario Selected: " + treeInspecting.ScenarioTreeKeyID);
            if (GUILayout.Button("X", GUILayout.Width(18f)))
            {
                treeInspecting = null;
            }
            DrawGrid(20, 0.2f, Color.gray);
            DrawGrid(100, 0.4f, Color.gray);

            DrawNodes();
            DrawConnections();

            DrawConnectionLine(Event.current);

            ProcessNodeEvents(Event.current);
            ProcessEvents(Event.current);

            if (GUI.changed) Repaint();
        }
        else
        {
            EditorGUILayout.LabelField("No Scenarios Selected. Select one and click \"Open Scenario Tree View Window.\"");
        }
    }
    private List<Node> DrawTree(List<ScenarioLeaf> leafLayer, int layerNum)
    {
        List<ScenarioLeaf> nextLeavesToDraw = new List<ScenarioLeaf>();
        List<Node> layerNodes = new List<Node>();
        Vector2 pos = new Vector2(leafLayer.Count % 2 == 0 ? -125 : 0, 170 * layerNum);
        foreach (ScenarioLeaf leaf in leafLayer)
        {
            layerNodes.Add(AddNode(pos, leaf, treeInspecting.ScenarioTreeKeyID));
            pos.x += 250;
            foreach (ScenarioLeaf nextLeaf in leaf.previousLeaves)
            {
                if (!nextLeavesToDraw.Contains(nextLeaf))
                {
                    nextLeavesToDraw.Add(nextLeaf);
                }
            }
        }
        if (nextLeavesToDraw.Count != 0)
        {
            List<Node> nextNodesToConnect = DrawTree(nextLeavesToDraw, layerNum + 1);
            foreach (Node n in layerNodes)
            {
                if (layerNodes[layerNodes.Count - 1] == n)
                {
                    //If the actual node is the last of the layer:
                    n.isLastOfRow = true;
                }
                else
                {
                    n.isLastOfRow = false; //just in case
                }
                foreach (Node nextNode in nextNodesToConnect)
                {
                    if (nextNode.leaf.nextLeaves.Contains(n.leaf))
                    {
                        //Link them. I think.
                        CreateConnection(nextNode, n);
                    }
                }
            }
            layerNodes.AddRange(nextNodesToConnect);
        }
        else
        {
            //Drew every nodes. Draw the connections then :)

        }
        return layerNodes;
    }
    private void DrawGrid(float gridSpacing, float gridOpacity, Color gridColor)
    {
        int widthDivs = Mathf.CeilToInt(position.width / gridSpacing);
        int heightDivs = Mathf.CeilToInt(position.height / gridSpacing);

        Handles.BeginGUI();
        Handles.color = new Color(gridColor.r, gridColor.g, gridColor.b, gridOpacity);

        offset += drag * 0.5f;
        Vector3 newOffset = new Vector3(offset.x % gridSpacing, offset.y % gridSpacing, 0);

        for (int i = 0; i < widthDivs; i++)
        {
            Handles.DrawLine(new Vector3(gridSpacing * i, -gridSpacing, 0) + newOffset, new Vector3(gridSpacing * i, position.height, 0f) + newOffset);
        }

        for (int j = 0; j < heightDivs; j++)
        {
            Handles.DrawLine(new Vector3(-gridSpacing, gridSpacing * j, 0) + newOffset, new Vector3(position.width, gridSpacing * j, 0f) + newOffset);
        }

        Handles.color = Color.white;
        Handles.EndGUI();
    }
    private void DrawNodes()
    {
        if (nodes != null)
        {
            for (int i = 0; i < nodes.Count; i++)
            {
                nodes[i].Draw();
            }
        }
    }
    private void DrawConnections()
    {
        if (connections != null)
        {
            for (int i = 0; i < connections.Count; i++)
            {
                connections[i].Draw();
            }
        }
    }
    private void ProcessEvents(Event e)
    {
        drag = Vector2.zero;

        switch (e.type)
        {
            case EventType.ScrollWheel:
                OnZoom(e.delta);
                break;
            case EventType.MouseDown:
                if (e.button == 0)
                {
                    if (selectedInPoint != null)
                    {
                        Node newNode = AddNewNode(e.mousePosition, treeInspecting.ScenarioTreeKeyID);
                        nodes.Add(newNode);
                        CreateConnection(newNode, selectedInPoint.node);
                        //selectedOutPoint = newNode.outPoint;
                    }
                    else if (selectedOutPoint != null)
                    {
                        Node newNode = AddNewNode(e.mousePosition, treeInspecting.ScenarioTreeKeyID);
                        nodes.Add(newNode);
                        CreateConnection(selectedOutPoint.node, newNode);
                        //selectedInPoint = newNode.inPoint;
                    }
                    ClearConnectionSelection();
                }

                if (e.button == 1)
                {
                    ProcessContextMenu(e.mousePosition);
                }
                break;

            case EventType.MouseDrag:
                if (e.button == 0)
                {
                    OnDrag(e.delta);
                }
                break;
        }
    }
    private void ProcessNodeEvents(Event e)
    {
        if (nodes != null)
        {
            for (int i = nodes.Count - 1; i >= 0; i--)
            {
                bool guiChanged = nodes[i].ProcessEvents(e);

                if (guiChanged)
                {
                    GUI.changed = true;
                }
            }
        }
    }
    private void DrawConnectionLine(Event e)
    {
        if (selectedInPoint != null && selectedOutPoint == null)
        {
            Handles.DrawBezier(
                selectedInPoint.rect.center,
                e.mousePosition,
                selectedInPoint.rect.center + Vector2.left * 50f,
                e.mousePosition - Vector2.left * 50f,
                Color.white,
                null,
                2f
            );

            GUI.changed = true;
        }

        if (selectedOutPoint != null && selectedInPoint == null)
        {
            Handles.DrawBezier(
                selectedOutPoint.rect.center,
                e.mousePosition,
                selectedOutPoint.rect.center - Vector2.left * 50f,
                e.mousePosition + Vector2.left * 50f,
                Color.white,
                null,
                2f
            );

            GUI.changed = true;
        }
    }
    private void ProcessContextMenu(Vector2 mousePosition)
    {
        GenericMenu genericMenu = new GenericMenu();
        genericMenu.AddItem(new GUIContent("Add Empty Leaf"), false, () => nodes.Add(AddNewNode(new Vector2(mousePosition.x,mousePosition.y), treeInspecting.ScenarioTreeKeyID)));
        genericMenu.AddItem(new GUIContent("Recenter"), false, () => Recenter());
        genericMenu.ShowAsContext();
    }
    private void Recenter()
    {
        if (nodes != null) offset = nodes[0].rect.position;
    }
    private void OnDrag(Vector2 delta)
    {
        drag = delta;

        if (nodes != null)
        {
            for (int i = 0; i < nodes.Count; i++)
            {
                nodes[i].Drag(delta);
            }
        }

        GUI.changed = true;
    }
    private void OnZoom(Vector2 delta)
    {
        if(nodes != null)
        {
            foreach (Node n in nodes)
            {
                n.Zoom(delta);
            }
        }
    }
    private void OnClickAddNode(Vector2 mousePosition)
    {
        if (nodes == null)
        {
            nodes = new List<Node>();
        }

        nodes.Add(new Node(mousePosition, 200, 50, nodeStyle, selectedNodeStyle, inPointStyle, outPointStyle, OnClickInPoint, OnClickOutPoint, OnClickRemoveNode));
    }
    private Node AddNewNode(Vector2 pos, string scenarName)
    {
        if (nodes == null)
        {
            nodes = new List<Node>();
        }
        CheckWholePath(scenarName);
        string pathToScenarFolder = $"Assets/Scenarios/" + scenarName;
        string pathToLeaves = pathToScenarFolder + "/Leaves";
        GameObject leaf;
        try
        {
            leaf = AssetDatabase.LoadAssetAtPath<ScenarioLeaf>(pathToLeaves + "/Leaves " + scenarName + ".prefab").gameObject;
        }
        catch
        {
            GameObject go = new GameObject();
            leaf = PrefabUtility.SaveAsPrefabAsset(go, pathToLeaves + "/Leaves " + scenarName + ".prefab");
            DestroyImmediate(go);
        }
        ScenarioLeaf newLeaf = leaf.AddComponent<ScenarioLeaf>();

        treeInspecting.Leaves.Add(newLeaf);
        Node res = new Node(pos, 200, 50, nodeStyle, selectedNodeStyle, inPointStyle, outPointStyle, OnClickInPoint, OnClickOutPoint, OnClickRemoveNode, newLeaf, scenarName);
        //nodes.Add(res);
        return res;
    }
    private Node AddNode(Vector2 pos, ScenarioLeaf leaf, string scenarName)
    {
        if (nodes == null)
        {
            nodes = new List<Node>();
        }
        Node res = new Node(pos, 200, 50, nodeStyle, selectedNodeStyle, inPointStyle, outPointStyle, OnClickInPoint, OnClickOutPoint, OnClickRemoveNode, leaf, scenarName);
        //nodes.Add(res);
        return res;
    }
    private Node AddNode(Vector2 pos, ScenarioLeaf leaf, string scenarName, bool Last)
    {
        if (nodes == null)
        {
            nodes = new List<Node>();
        }
        Node res = new Node(Last, pos, 200, 50, nodeStyle, selectedNodeStyle, inPointStyle, outPointStyle, OnClickInPoint, OnClickOutPoint, OnClickRemoveNode, leaf, scenarName);
        //nodes.Add(res);
        return res;
    }
    private void OnClickInPoint(ConnectionPoint inPoint)
    {
        selectedInPoint = inPoint;

        if (selectedOutPoint != null)
        {
            if (selectedOutPoint.node != selectedInPoint.node)
            {
                CreateConnection();
                ClearConnectionSelection();
            }
            else
            {
                ClearConnectionSelection();
            }
        }
        //Debug.Log("This is an IN point");
    }
    private void OnClickOutPoint(ConnectionPoint outPoint)
    {
        selectedOutPoint = outPoint;

        if (selectedInPoint != null)
        {
            if (selectedOutPoint.node != selectedInPoint.node)
            {
                CreateConnection();
                ClearConnectionSelection();
            }
            else
            {
                ClearConnectionSelection();
            }
        }
        //Debug.Log("This is an OUT point");

    }
    private void OnClickRemoveNode(Node node)
    {
        foreach (ScenarioLeaf l in node.leaf.nextLeaves)
        {
            l.previousLeaves.Remove(node.leaf);
        }
        foreach (ScenarioLeaf l in node.leaf.previousLeaves)
        {
            l.nextLeaves.Remove(node.leaf);
        }
        treeInspecting.Leaves.Remove(node.leaf);
        DestroyImmediate(node.leaf, true);
        if (connections != null)
        {
            List<Connection> connectionsToRemove = new List<Connection>();

            for (int i = 0; i < connections.Count; i++)
            {
                if (connections[i].inPoint == node.inPoint || connections[i].outPoint == node.outPoint)
                {
                    connectionsToRemove.Add(connections[i]);
                }
            }

            for (int i = 0; i < connectionsToRemove.Count; i++)
            {
                connections.Remove(connectionsToRemove[i]);
            }

            connectionsToRemove = null;
        }

        nodes.Remove(node);
    }
    private void OnClickRemoveConnection(Connection connection)
    {
        connections.Remove(connection);
        //Make the connection REALLY dissapear.
        //Out->in
        //out's next leaf == leaf -> true
        ScenarioLeaf inLeaf = connection.inPoint.node.leaf;
        ScenarioLeaf outLeaf = connection.outPoint.node.leaf;
        connection.outPoint.node.leaf.nextLeaves.Remove(inLeaf);
        connection.inPoint.node.leaf.previousLeaves.Remove(outLeaf);
    }
    private void CreateConnection()
    {
        CheckWholePath(treeInspecting.ScenarioTreeKeyID);
        if (connections == null)
        {
            connections = new List<Connection>();
        }

        Connection conToMake = new Connection(selectedInPoint, selectedOutPoint, OnClickRemoveConnection, treeInspecting.ScenarioTreeKeyID, connections.Count, this);
        if (!connections.Contains(conToMake))
        {
            connections.Add(conToMake);

            selectedInPoint.node.leaf.previousLeaves.Add(selectedOutPoint.node.leaf);
            selectedOutPoint.node.leaf.nextLeaves.Add(selectedInPoint.node.leaf);
        }
    }
    private void CreateConnection(Node left, Node right)
    {
        if (connections == null)
        {
            connections = new List<Connection>();
        }
        //"graphical" part. Does drawing + nodal link, via code.
        Connection conToMake = new Connection(right.inPoint, left.outPoint, OnClickRemoveConnection, treeInspecting.ScenarioTreeKeyID, connections.Count, this);
        if (!connections.Contains(conToMake))
        {
            connections.Add(conToMake);
            right.leaf.previousLeaves.Add(left.leaf);
            left.leaf.nextLeaves.Add(right.leaf);
        }
        //Link the leaves.

    }
    private void ClearConnectionSelection()
    {
        selectedInPoint = null;
        selectedOutPoint = null;
    }
    void CheckWholePath(string scenarname)
    {
        ///<summary> Check for the whole path of a scenario, create the folders if not created.</summary>
        pathToScenarFolder = $"Assets/Scenarios/" + scenarname;
        pathToLeaves = pathToScenarFolder + "/Leaves";
        pathToActions = pathToLeaves + "/Actions";
        pathToReq = pathToLeaves + "/Requirements";

        if (!AssetDatabase.IsValidFolder(pathToScenarFolder))                               //If the path doesn't exist:
        {
            if (!AssetDatabase.IsValidFolder($"Assets/Scenarios"))                          //If the scenario folder doesn't exists:
            {
                AssetDatabase.CreateFolder($"Assets", "Scenarios");                         //Creates folder for all the scenarios
            }
            if (scenarname != "")
                AssetDatabase.CreateFolder($"Assets/Scenarios", scenarname);    //Creates a folder for our scenario
        }
        if (!AssetDatabase.IsValidFolder($"Assets/Scenarios/ImportedScenarios"))
        {
            AssetDatabase.CreateFolder($"Assets/Scenarios", "ImportedScenarios");   //{"ScenarioTreeKeyID":"fefefef","Leaves":[{"instanceID":15948},{"instanceID":15950},{"instanceID":15952}],"IsLockedAtFirst":false,"choicesMade":[],"isActualScenario":false}
        }
        if (!AssetDatabase.IsValidFolder(pathToLeaves))                             //If there isn't the path to ScenarioTreeKeyID
        {
            AssetDatabase.CreateFolder(pathToScenarFolder, "Leaves");               //create it
        }
        if (!AssetDatabase.IsValidFolder(pathToActions))
        {
            AssetDatabase.CreateFolder(pathToLeaves, "Actions");               //create it
        }
        if (!AssetDatabase.IsValidFolder(pathToReq))
        {
            AssetDatabase.CreateFolder(pathToLeaves, "Requirements");               //create it
        }
    }
    #endregion
    public bool HasOverlappingRect(Rect rectToCheck)
    {
        bool res = false;

        foreach (Connection c in connections)
        {
            if (rectToCheck.Overlaps(c.ReqTypeRect) && (c.ReqTypeRect != rectToCheck))
            {
                res = true;
            }

        }
        return res;
    }
}