A!leys Galerie

```csharp
using UnityEngine;
using UnityEngine.UI;
using System.Collections.Generic;
using System.Linq;
using DG.Tweening;
using UnityEngine.EventSystems;

[RequireComponent(typeof(GraphCanvas))]
[ExecuteAlways]
public class DynamicTweenFlow : MonoBehaviour, IBeginDragHandler, IDragHandler, IEndDragHandler
{
    [SerializeField] private float minNodeSize = 30f;
    [SerializeField] private float maxNodeSize = 100f;
    [SerializeField] private Color defaultNodeColor = new Color(0.2f, 0.6f, 0.9f);
    [SerializeField] private Color highlightColor = Color.yellow;
    [SerializeField] private Color warningColor = Color.red;
    [SerializeField] private float connectionThickness = 2f;
    [SerializeField] private float minConnectionDistance = 50f;
    [SerializeField] private float dragSpeedMultiplier = 0.5f;
    [SerializeField] private float zoomSpeed = 2f;
    [SerializeField] private float minZoom = 0.1f;
    [SerializeField] private float maxZoom = 5f;
    [SerializeField] private AnimationCurve zoomCurve;

    private GraphCanvas canvas;
    private List<Node> nodes = new List<Node>();
    private List<Connection> connections = new List<Connection>();
    private Node selectedNode;
    private Vector2 lastDragPosition;
    private float currentZoom = 1f;
    private RectTransform canvasRect;
    private bool isDragging = false;
    private bool isGeneratingCode = false;
    private string generatedCode;

    private enum NodeType { Tween, Property, Event, None }
    private enum ConnectionType { Tween, Flow, None }

    [System.Serializable]
    public class Node
    {
        public Vector2 position;
        public NodeType type;
        public string name = "New Node";
        public string propertyPath;
        public Ease easeType;
        public float duration = 1f;
        public float delay = 0f;
        public bool isLoop;
        public bool isActive = true;
        public Color color;
        public RectTransform rectTransform;
        public List<int> incomingConnections = new List<int>();
        public List<int> outgoingConnections = new List<int>();

        public Node(NodeType type, string name = "New Node")
        {
            this.type = type;
            this.name = name;
            this.color = defaultNodeColor;
            this.easeType = Ease.InOutQuad;
        }

        public void UpdateVisuals()
        {
            if (rectTransform == null) return;

            // Dynamic size based on content and type
            float size = minNodeSize + (type == NodeType.Property ? 20f : 0);
            size = Mathf.Clamp(size, minNodeSize, maxNodeSize);
            rectTransform.sizeDelta = new Vector2(size, size);

            // Update color based on state
            if (incomingConnections.Count == 0 && outgoingConnections.Count == 0)
                color = warningColor;
            else if (incomingConnections.Count > 0)
                color = defaultNodeColor;
            else if (selectedNode == this)
                color = highlightColor;
            else
                color = defaultNodeColor * 0.8f;

            GetComponent<Image>().color = color;

            // Update text based on type
            Text text = GetComponentInChildren<Text>();
            if (text == null) return;

            switch (type)
            {
                case NodeType.Tween:
                    text.text = name + "\n" + $"Dur: {duration:F1}s\nEase: {easeType}";
                    break;
                case NodeType.Property:
                    text.text = propertyPath;
                    break;
                case NodeType.Event:
                    text.text = name;
                    break;
                default:
                    text.text = name;
                    break;
            }
        }
    }

    [System.Serializable]
    public class Connection
    {
        public int fromNodeIndex;
        public int toNodeIndex;
        public ConnectionType type;
        public LineRenderer lineRenderer;
        public bool isValid = true;

        public Connection(int from, int to, ConnectionType type)
        {
            fromNodeIndex = from;
            toNodeIndex = to;
            this.type = type;
            CreateLineRenderer();
        }

        private void CreateLineRenderer()
        {
            GameObject lineObj = new GameObject("ConnectionLine_" + fromNodeIndex + "_" + toNodeIndex);
            lineObj.transform.SetParent(transform);
            lineRenderer = lineObj.AddComponent<LineRenderer>();
            lineRenderer.startWidth = connectionThickness;
            lineRenderer.endWidth = connectionThickness;
            lineRenderer.positionCount = 2;
            lineRenderer.useWorldSpace = true;
            lineRenderer.material = new Material(Shader.Find("Sprites/Default"));
            lineRenderer.startColor = type == ConnectionType.Tween ? Color.green : Color.blue;
            lineRenderer.endColor = type == ConnectionType.Tween ? Color.green : Color.blue;
        }

        public void UpdateLine()
        {
            if (lineRenderer == null) return;

            if (fromNodeIndex >= nodes.Count || toNodeIndex >= nodes.Count)
            {
                Destroy(lineRenderer.gameObject);
                return;
            }

            Node fromNode = nodes[fromNodeIndex];
            Node toNode = nodes[toNodeIndex];

            if (fromNode.rectTransform == null || toNode.rectTransform == null)
            {
                Destroy(lineRenderer.gameObject);
                return;
            }

            Vector3[] positions = new Vector3[2];
            positions[0] = fromNode.rectTransform.rect.center + fromNode.rectTransform.anchoredPosition;
            positions[1] = toNode.rectTransform.rect.center + toNode.rectTransform.anchoredPosition;
            lineRenderer.SetPositions(positions);

            // Check if connection is valid (not overlapping nodes)
            isValid = Vector2.Distance(positions[0], positions[1]) > minConnectionDistance;

            if (!isValid)
            {
                lineRenderer.startColor = warningColor;
                lineRenderer.endColor = warningColor;
            }
            else
            {
                lineRenderer.startColor = type == ConnectionType.Tween ? Color.green : Color.blue;
                lineRenderer.endColor = type == ConnectionType.Tween ? Color.green : Color.blue;
            }
        }

        public void DestroyLine()
        {
            if (lineRenderer != null)
                Destroy(lineRenderer.gameObject);
        }
    }

    private void Awake()
    {
        if (canvas == null)
            canvas = GetComponent<GraphCanvas>();

        if (canvasRect == null)
            canvasRect = canvas.GetComponent<RectTransform>();

        // Initialize with default nodes
        if (nodes.Count == 0)
        {
            CreateDefaultNodes();
        }
    }

    private void CreateDefaultNodes()
    {
        // Property node (start)
        Node startNode = new Node(NodeType.Property, "Start Position");
        startNode.propertyPath = "transform.localPosition";
        nodes.Add(startNode);

        // Tween node
        Node tweenNode = new Node(NodeType.Tween, "Move Tween");
        tweenNode.duration = 2f;
        nodes.Add(tweenNode);

        // Property node (end)
        Node endNode = new Node(NodeType.Property, "End Position");
        endNode.propertyPath = "transform.localPosition";
        nodes.Add(endNode);

        // Create connections
        connections.Add(new Connection(0, 1, ConnectionType.Tween));
        connections.Add(new Connection(1, 2, ConnectionType.Flow));

        UpdateAllNodes();
    }

    private void UpdateAllNodes()
    {
        foreach (Node node in nodes)
        {
            if (node.rectTransform == null)
            {
                CreateNodeUI(node);
            }
            node.UpdateVisuals();
        }

        foreach (Connection conn in connections)
        {
            conn.UpdateLine();
        }

        GenerateCode();
    }

    private void CreateNodeUI(Node node)
    {
        GameObject nodeObj = new GameObject(node.name);
        nodeObj.transform.SetParent(canvas.transform);
        node.rectTransform = nodeObj.AddComponent<RectTransform>();
        node.rectTransform.anchorMin = Vector2.zero;
        node.rectTransform.anchorMax = Vector2.one;
        node.rectTransform.sizeDelta = new Vector2(minNodeSize, minNodeSize);
        node.rectTransform.anchoredPosition = node.position;

        Image nodeImage = nodeObj.AddComponent<Image>();
        nodeImage.color = node.color;
        nodeImage.preserveAspect = true;

        // Add label
        GameObject labelObj = new GameObject("Label");
        labelObj.transform.SetParent(nodeObj.transform);
        Text label = labelObj.AddComponent<Text>();
        label.alignment = TextAnchor.MiddleCenter;
        label.fontSize = Mathf.RoundToInt(minNodeSize * 0.6f);
        label.color = Color.white;
        nodeObj.AddComponent<Node>().Initialize(node, label);

        // Add drag handler
        nodeObj.AddComponent<NodeDragHandler>().Initialize(node);
    }

    private void GenerateCode()
    {
        if (isGeneratingCode) return;
        isGeneratingCode = true;

        generatedCode = GenerateTweenSequence();
        Debug.Log("Generated Tween Code:\n" + generatedCode);

        isGeneratingCode = false;
    }

    private string GenerateTweenSequence()
    {
        string code = "using DG.Tweening;\nusing UnityEngine;\n\n";

        if (connections.Count == 0)
        {
            code += "// No valid tween sequence found. Create connections to generate code.\n";
            return code;
        }

        // Find the starting node (node with no incoming connections)
        Node startNode = nodes.FirstOrDefault(n => n.incomingConnections.Count == 0);
        if (startNode == null)
        {
            code += "// No starting node found (node with no incoming connections).\n";
            return code;
        }

        code += "public class GeneratedTweenSequence : MonoBehaviour\n{\n";
        code += "    void Start()\n    {\n";

        code += $"        // Start tween from {startNode.name}\n";
        if (startNode.type == NodeType.Property)
        {
            code += $"        Tween tween = DOTween.To(() => transform.{startNode.propertyPath}, x => transform.{startNode.propertyPath} = x,\n";
            code += $"            new Vector3(0, 0, 0), // Default target (will be replaced)\n";
            code += $"            {startNode.duration}.f).SetEase({GetEaseName(startNode.easeType)}).SetDelay({startNode.delay})\n";

            // Find all tween nodes connected to this
            foreach (int outgoingIndex in startNode.outgoingConnections)
            {
                Connection conn = connections[outgoingIndex];
                if (conn.type == ConnectionType.Tween)
                {
                    Node tweenNode = nodes[conn.toNodeIndex];
                    code += $".OnComplete(() =>\n" +
                            $"    DOTween.To(() => transform.{tweenNode.propertyPath}, x => transform.{tweenNode.propertyPath} = x,\n" +
                            $"        new Vector3({GetRandomVector3()}), // Target position\n" +
                            $"        {tweenNode.duration}.f).SetEase({GetEaseName(tweenNode.easeType)})\n";
                }
            }
        }

        code += ";\n";
        code += "    }\n";
        code += "}\n";

        return code;
    }

    private string GetEaseName(Ease ease)
    {
        return ease switch
        {
            Ease.InQuad => "Ease.InQuad",
            Ease.OutQuad => "Ease.OutQuad",
            Ease.InOutQuad => "Ease.InOutQuad",
            Ease.InExpo => "Ease.InExpo",
            Ease.OutExpo => "Ease.OutExpo",
            Ease.InOutExpo => "Ease.InOutExpo",
            Ease.InCirc => "Ease.InCirc",
            Ease.OutCirc => "Ease.OutCirc",
            Ease.InOutCirc => "Ease.InOutCirc",
            _ => "Ease.Linear"
        };
    }

    private Vector3 GetRandomVector3()
    {
        return new Vector3(Random.Range(-5, 5), Random.Range(-5, 5), Random.Range(-5, 5));
    }

    #region UI Interactions

    public void OnBeginDrag(PointerEventData eventData)
    {
        if (!canvas.IsPointerOverCanvas(eventData))
            return;

        lastDragPosition = eventData.position;
        isDragging = true;
    }

    public void OnDrag(PointerEventData eventData)
    {
        if (!isDragging || !canvas.IsPointerOverCanvas(eventData))
            return;

        Vector2 delta = eventData.position - lastDragPosition;
        lastDragPosition = eventData.position;

        // Handle zoom with pinch (mobile) or mouse wheel (desktop)
        if (eventData.pointerCount > 1)
        {
            float pinchDelta = GetPinchDelta(eventData);
            ZoomCamera(pinchDelta * zoomSpeed);
        }
        else if (Input.GetAxis("Mouse ScrollWheel") != 0)
        {
            ZoomCamera(Input.GetAxis("Mouse ScrollWheel") * zoomSpeed);
        }
        else
        {
            // Pan the camera
            Vector2 pan = Camera.main.ScreenToViewportPoint(delta) * currentZoom;
            camera.transform.Translate(new Vector3(pan.x, pan.y, 0), Space.World);
        }
    }

    public void OnEndDrag(PointerEventData eventData)
    {
        isDragging = false;
    }

    private float GetPinchDelta(PointerEventData eventData)
    {
        if (eventData.pointerCount < 2) return 0f;

        Vector2 firstPos, secondPos;
        eventData.GetPosition(out firstPos);
        eventData.GetPosition(out secondPos, 1);

        Vector2 prevFirst, prevSecond;
        eventData.GetPreviousPosition(out prevFirst);
        eventData.GetPreviousPosition(out prevSecond, 1);

        float prevDistance = Vector2.Distance(prevFirst, prevSecond);
        float currentDistance = Vector2.Distance(firstPos, secondPos);

        return currentDistance / (prevDistance + 0.001f);
    }

    private void ZoomCamera(float zoomFactor)
    {
        zoomFactor = Mathf.Clamp(zoomFactor, -1f, 1f);
        currentZoom = Mathf.Clamp(currentZoom + zoomFactor, minZoom, maxZoom);

        // Apply zoom curve for smoother feel
        currentZoom = Mathf.Clamp(zoomCurve.Evaluate(currentZoom), minZoom, maxZoom);

        // Update camera orthographic size
        Camera.main.orthographicSize = currentZoom * 5f;

        // Update all node positions to maintain relative positioning
        Vector2 center = canvasRect.rect.center;
        foreach (Node node in nodes)
        {
            if (node.rectTransform != null)
            {
                Vector2 newPos = node.rectTransform.anchoredPosition;
                newPos.x = Mathf.Lerp(newPos.x, center.x, 0.1f * currentZoom);
                newPos.y = Mathf.Lerp(newPos.y, center.y, 0.1f * currentZoom);
                node.rectTransform.anchoredPosition = newPos;
            }
        }
    }

    #endregion

    #region Node Management

    public void AddNode(NodeType type, Vector2 position = default)
    {
        Node newNode = new Node(type);
        newNode.position = position == default ? Camera.main.ScreenToViewportPoint(Input.mousePosition) * 1000f : position;
        nodes.Add(newNode);
        CreateNodeUI(newNode);
        UpdateAllNodes();
    }

    public void RemoveNode(int index)
    {
        if (index < 0 || index >= nodes.Count) return;

        // Remove all connections to/from this node
        connections.RemoveAll(c => c.fromNodeIndex == index || c.toNodeIndex == index);

        // Update other nodes' connection lists
        foreach (Node node in nodes)
        {
            node.incomingConnections.Remove(index);
            node.outgoingConnections.Remove(index);
        }

        Destroy(nodes[index].rectTransform.gameObject);
        nodes.RemoveAt(index);
        UpdateAllNodes();
    }

    public void AddConnection(int fromIndex, int toIndex, ConnectionType type)
    {
        if (fromIndex < 0 || fromIndex >= nodes.Count || toIndex < 0 || toIndex >= nodes.Count) return;
        if (fromIndex == toIndex) return; // No self connections

        // Check if connection already exists
        if (connections.Exists(c => c.fromNodeIndex == fromIndex && c.toNodeIndex == toIndex))
            return;

        connections.Add(new Connection(fromIndex, toIndex, type));
        nodes[fromIndex].outgoingConnections.Add(connections.Count - 1);
        nodes[toIndex].incomingConnections.Add(connections.Count - 1);
        UpdateAllNodes();
    }

    public void RemoveConnection(int connectionIndex)
    {
        if (connectionIndex < 0 || connectionIndex >= connections.Count) return;

        Connection conn = connections[connectionIndex];
        nodes[conn.fromNodeIndex].outgoingConnections.Remove(connectionIndex);
        nodes[conn.toNodeIndex].incomingConnections.Remove(connectionIndex);
        conn.DestroyLine();
        connections.RemoveAt(connectionIndex);
        UpdateAllNodes();
    }

    #endregion

    #region Editor Tools

    public void ResetGraph()
    {
        foreach (Connection conn in connections)
        {
            conn.DestroyLine();
        }
        connections.Clear();

        foreach (Node node in nodes)
        {
            Destroy(node.rectTransform.gameObject);
        }
        nodes.Clear();

        CreateDefaultNodes();
    }

    public void ExportCodeToFile()
    {
        if (string.IsNullOrEmpty(generatedCode))
        {
            Debug.LogWarning("No code to export. Create a valid tween sequence first.");
            return;
        }

        string filePath = System.IO.Path.Combine(Application.persistentDataPath, "GeneratedTweenSequence.cs");
        System.IO.File.WriteAllText(filePath, generatedCode);
        Debug.Log($"Code exported to: {filePath}");
    }

    #endregion