private void CreateLoadedNodes()
    {
        foreach (RoomNodeData rData in m_graphToLoadCache.m_roomNodeDataList)
        {
            RoomNode l_tempRoom = m_targetGraph.CreateRoomNode(rData.nodeType, rData.isTerminal);
            l_tempRoom.roomID = rData.nodeID;
            l_tempRoom.RefreshExpandedState();
            m_targetGraph.AddElement(l_tempRoom);

            List <RoomNodeConnectionsData> l_tempOutRoomPorts = m_graphToLoadCache.m_roomConnectionsDataList.Where(x => x.baseNodeId == rData.nodeID).ToList();
            l_tempOutRoomPorts.ForEach(x => m_targetGraph.GenerateOutputPortsOnNode(l_tempRoom, x.basePortName));

            List <RoomNodeConnectionsData> l_tempInputRoomPorts = m_graphToLoadCache.m_roomConnectionsDataList.Where(x => x.targetNodeId == rData.nodeID).ToList();
            l_tempInputRoomPorts.ForEach(x => m_targetGraph.GenerateInputPortsOnNode(l_tempRoom, x.targetPortName));
        }
    }
    private void CreateExpandedNodes(RoomInfoContainer _graphToLoadCache, RoomNode roomToExpand)
    {
        List <RoomNode> l_newInstantiatedRoomsList = new List <RoomNode>();

        foreach (RoomNodeData rData in _graphToLoadCache.m_roomNodeDataList)                    //para cada nodo en el nuevo grafico (la regla que acabo de cargar);
        {
            RoomNode l_tempRoom = m_graphView.CreateRoomNode(rData.nodeType, rData.isTerminal); //instancio el nodo
            l_newInstantiatedRoomsList.Add(l_tempRoom);                                         //lo añado a la lista de "nuevas salas"
            l_tempRoom.roomID = rData.nodeID;                                                   //le asigno su ID
            m_graphView.AddElement(l_tempRoom);                                                 //añado el elemento al grafico

            //creo los puertos de entrada y salida que le tocan al nodo
            List <RoomNodeConnectionsData> l_tempOutRoomPorts = _graphToLoadCache.m_roomConnectionsDataList.Where(x => x.baseNodeId == rData.nodeID).ToList();
            l_tempOutRoomPorts.ForEach(x => m_graphView.GenerateOutputPortsOnNode(l_tempRoom, x.basePortName));

            List <RoomNodeConnectionsData> l_tempInputRoomPorts = _graphToLoadCache.m_roomConnectionsDataList.Where(x => x.targetNodeId == rData.nodeID).ToList();
            l_tempInputRoomPorts.ForEach(x => m_graphView.GenerateInputPortsOnNode(l_tempRoom, x.targetPortName));
        }
        for (int i = 0; i < l_newInstantiatedRoomsList.Count; i++)// para cada nodo que acabo de instanciar
        {
            //busco las conexiones que tiene
            List <RoomNodeConnectionsData> l_connectionDataCache = _graphToLoadCache.m_roomConnectionsDataList.Where(x => x.baseNodeId == l_newInstantiatedRoomsList[i].roomID).ToList();

            for (int j = 0; j < l_connectionDataCache.Count; j++)
            {
                string   l_targetNodeId = l_connectionDataCache[j].targetNodeId;                                                                            //guardo el id del nodo target
                RoomNode l_targetRoom   = l_newInstantiatedRoomsList.First(x => x.roomID == l_targetNodeId);                                                //busco la sala que conicida con ese ID

                string l_targetPortName = l_connectionDataCache[j].targetPortName;                                                                          //guardo el nombre del puerto target

                Port l_targetPortToConnect = m_graphView.ports.ToList().First(x => (x.node as RoomNode) == l_targetRoom && x.portName == l_targetPortName); //busco el puerto al que me tengo que conectar

                //si es un nodo 'begin', marco este nodo como el beginNodeInstantiated (en el begin node empieza la regla) -> sirve como referencia para saber donde empezar a conectar el puerto q quiero expandir
                if (l_newInstantiatedRoomsList[i].roomType == "begin")
                {
                    m_beginNodeInstantiated = l_newInstantiatedRoomsList[i];
                }

                //conecto el puerto del nodo [i] con el targetPort -> en este primer linkado asigno el tempEdge a una variable m_currentBeginNodeEdge
                //que luego me servira para encontrar el nodo conectado al nodo 'begin'
                LinkRoomPorts(l_newInstantiatedRoomsList[i].outputContainer[j].Q <Port>(), l_targetPortToConnect);

                //seteo su position basadome en la posicion del nodo expandido
                l_targetRoom.SetPosition(new Rect(_graphToLoadCache.m_roomNodeDataList.First(x => x.nodeID == l_targetRoom.roomID).position +
                                                  roomToExpand.GetPosition().position, m_graphView.defaultNodeSize));
            } //end for
        }     //end of for loop

        //busco el puerto de entrada al que esta conectado la habitacion que quiero expandir
        Port l_basePort = m_graphView.edges.ToList().Find(x => (x.input.node as RoomNode) == roomToExpand).output;

        l_basePort.portColor = new Color(0, 0, 200);//blue

        //el puerto target será el que hemos marcado previamente al conectar los nodos de la regla que acabamos de cargar
        //el currentBeginNodeEdge es la conexion del nodo 'begin' -> cojemos el input, que es el puerto q pertenece al nodo 'begin'
        Port l_targetPort = m_currentBeginNodeEdge.input;

        l_targetPort.portColor = new Color(200, 0, 0);                                                     //red
        l_targetPort.portName  = m_UtilitiesInstance.ReturnConnectionNameByReference(l_basePort.portName); //asignar el nuevo nombre del puerto dependiendo del puerto base conectado

        //elimino el nodo 'begin' -> solo sirve como referencia para saber donde conectar el nodo que queremos expandir
        m_graphView.RemoveElement(m_beginNodeInstantiated);

        //conecto los puertos
        LinkRoomPorts(l_basePort, l_targetPort);

        List <RoomNode> l_currentNodesOnGraph = m_graphView.nodes.ToList().Cast <RoomNode>().ToList();

        //asignar nuevas id a cada nodo
        for (int i = 0; i < l_currentNodesOnGraph.Count; i++)
        {
            for (int j = 0; j < l_newInstantiatedRoomsList.Count(); j++)
            {
                if (l_currentNodesOnGraph[i] == l_newInstantiatedRoomsList[j])
                {
                    List <Edge> l_currentOutputRoomEdges = m_graphView.edges.ToList().Where(x => (x.output.node as RoomNode) == l_currentNodesOnGraph[i]).ToList();
                    List <Edge> l_currentInputRoomEdges  = m_graphView.edges.ToList().Where(x => (x.input.node as RoomNode) == l_currentNodesOnGraph[i]).ToList();

                    string l_newRoomID = l_currentNodesOnGraph[i].roomID = System.Guid.NewGuid().ToString();

                    foreach (Edge e in l_currentOutputRoomEdges)
                    {
                        e.output.name = l_newRoomID;
                    }
                    foreach (Edge e in l_currentInputRoomEdges)
                    {
                        e.input.name = l_newRoomID;
                    }
                }
            }
        } //end of for loop
    }     //end expand nodes function