コード例 #1
0
    public TimeStepData Copy(TimeStepData _timeStep)
    {
        TimeStepData timeStep = new TimeStepData();

        for (int i = 0; i < _timeStep.threads.Count; i++)
        {
            ThreadData thread = new ThreadData();
            thread.id       = _timeStep.threads[i].id;
            thread.pos      = new Vector2(_timeStep.threads[i].pos.x, _timeStep.threads[i].pos.y);
            thread.rotation = new Vector3(_timeStep.threads[i].rotation.x, _timeStep.threads[i].rotation.y, _timeStep.threads[i].rotation.z);
            thread.packages = new List <PackageData>();
            for (int j = 0; j < _timeStep.threads[i].packages.Count; j++)
            {
                PackageData package = new PackageData();
                package.id     = _timeStep.threads[i].packages[j].id;
                package.active = _timeStep.threads[i].packages[j].active;
                thread.packages.Add(package);
            }
            timeStep.threads.Add(thread);
        }
        for (int i = 0; i < _timeStep.pickups.Count; i++)
        {
            PickupData pickup = new PickupData();
            pickup.id        = _timeStep.pickups[i].id;
            pickup.available = _timeStep.pickups[i].available;
            timeStep.pickups.Add(pickup);
        }
        for (int i = 0; i < _timeStep.deliveryPoints.Count; i++)
        {
            DeliveryData delivery = new DeliveryData();
            delivery.id         = _timeStep.deliveryPoints[i].id;
            delivery.deliveries = _timeStep.deliveryPoints[i].deliveries;
            timeStep.deliveryPoints.Add(delivery);
        }
        for (int i = 0; i < _timeStep.sempahores.Count; i++)
        {
            SemaphoreData semaphore = new SemaphoreData();
            semaphore.id   = _timeStep.sempahores[i].id;
            semaphore.open = _timeStep.sempahores[i].open;
            timeStep.sempahores.Add(semaphore);
        }
        for (int i = 0; i < _timeStep.conditionals.Count; i++)
        {
            ConditionalData conditional = new ConditionalData();
            conditional.id         = _timeStep.conditionals[i].id;
            conditional.current    = _timeStep.conditionals[i].current;
            conditional.directions = new string[_timeStep.conditionals[i].directions.Length];
            for (int j = 0; j < _timeStep.conditionals[i].directions.Length; j++)
            {
                conditional.directions[j] = _timeStep.conditionals[i].directions[j];
            }
            timeStep.conditionals.Add(conditional);
        }
        return(timeStep);
    }
コード例 #2
0
    IEnumerator ParseSteps()
    {
        playerInteraction.playerInteraction_UI.loadingText.text = "Parsing...";
        currentStep = 0;
        paused = false;
        Level lvl = GameManager.Instance.GetDataManager().currentLevelData;
        if(lvl.execution.Count > 0)
        {
            int maxStep = 0;
            stepDictionary = new Dictionary<int, List<StepData>>();
            Dictionary<int, List<int>> componentStepsDictionary = new Dictionary<int, List<int>>();
            timeSteps = new List<TimeStepData>();
            List<GridComponent> threads = new List<GridComponent>();

            foreach (GridComponent g in lvl.components)
            {
                if (g.type == "thread")
                {
                    threads.Add(g);
                }
            }

            yield return new WaitForSeconds(1f);
            System.Diagnostics.Stopwatch stopwatch = new System.Diagnostics.Stopwatch();
            stopwatch.Start();
            for (int i = 0; i < lvl.execution.Count; i++)
            {
                StepData step = lvl.execution[i];

                if (step.timeStep > maxStep)
                {
                    maxStep = step.timeStep;
                }

                if (step.eventType == "M")
                {
                    if (!componentStepsDictionary.ContainsKey(step.componentID)) { componentStepsDictionary.Add(step.componentID, new List<int>()); componentStepsDictionary[step.componentID].Add(i); }
                    else { componentStepsDictionary[step.componentID].Add(i); }
                }

                if (stepDictionary.ContainsKey(step.timeStep))
                {
                    if (step.eventType == "D")
                    {
                        stepDictionary[step.timeStep].Insert(0, step);
                    }
                    else
                    {
                        stepDictionary[step.timeStep].Add(step);
                    }
                }
                else
                {
                    stepDictionary[step.timeStep] = new List<StepData>();
                    stepDictionary[step.timeStep].Add(step);
                }
                if(stopwatch.ElapsedMilliseconds > 1000 / 60)
                {
                    stopwatch.Stop();
                    stopwatch.Reset();
                    yield return new WaitForEndOfFrame();
                    stopwatch.Start();
                }
            }

            //create in between steps for thread movements
            for (int i = 0; i <= maxStep; i++)
            {
                if (stepDictionary.ContainsKey(i) == false)
                    stepDictionary.Add(i, new List<StepData>());
                if (stepDictionary[i] == null)
                    stepDictionary[i] = new List<StepData>();
                if (stepDictionary[i].Count == 0)
                {
                    for (int j = 0; j < threads.Count; j++)
                    {
                        Vector2 prevPos = new Vector2();
                        if (i > 0)
                        {
                            for (int k = 0; k < stepDictionary[i - 1].Count; k++)
                            {
                                if (stepDictionary[i - 1][k].eventType == "M" && stepDictionary[i - 1][k].componentID == threads[j].id)
                                {
                                    prevPos = stepDictionary[i - 1][k].componentPos;
                                }
                            }
                        }
                        Vector2 nextPos = prevPos;
                        bool end = false;
                        for (int k = i + 1; k < maxStep+1; k++)
                        {
                            if (stepDictionary.ContainsKey(k))
                            {
                                for (int l = 0; l < stepDictionary[k].Count; l++)
                                {
                                    if (stepDictionary[k][l].eventType == "M" && stepDictionary[k][l].componentID == threads[j].id)
                                    {
                                        if (stepDictionary[k][l].componentPos != prevPos)
                                        {
                                            if (Vector2.Distance(prevPos, stepDictionary[k][l].componentPos) > 1 || Vector2.Distance(prevPos, stepDictionary[k][l].componentPos) < -1)
                                            {
                                                if (k - Mathf.Abs(Vector2.Distance(prevPos, stepDictionary[k][l].componentPos)) == i - 1)
                                                {
                                                    if (prevPos.x != stepDictionary[k][l].componentPos.x)
                                                    {
                                                        if (prevPos.x > stepDictionary[k][l].componentPos.x)
                                                        {
                                                            nextPos = new Vector2(nextPos.x - 1, nextPos.y);
                                                        }
                                                        else
                                                        {
                                                            nextPos = new Vector2(nextPos.x + 1, nextPos.y);
                                                        }
                                                    }
                                                    else
                                                    {
                                                        if (prevPos.y > stepDictionary[k][l].componentPos.y)
                                                        {
                                                            nextPos = new Vector2(nextPos.x, nextPos.y - 1);
                                                        }
                                                        else
                                                        {
                                                            nextPos = new Vector2(nextPos.x, nextPos.y + 1);
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        end = true;
                                        break;
                                    }
                                }
                                if (end == true)
                                {
                                    break;
                                }
                            }
                        }

                        StepData newStep = new StepData();
                        newStep.componentID = threads[j].id;
                        newStep.componentPos = nextPos;
                        newStep.eventType = "M";
                        newStep.timeStep = i;

                        stepDictionary[i].Add(newStep);
                    }

                }
                else
                {
                    List<bool> hasTimeStepData = new List<bool>();
                    for (int j = 0; j < threads.Count; j++)
                    {
                        hasTimeStepData.Add(false);
                    }

                    for (int j = 0; j < stepDictionary[i].Count; j++)
                    {
                        if (stepDictionary[i][j].eventType == "M")
                        {
                            for (int k = 0; k < threads.Count; k++)
                            {
                                if (threads[k].id == stepDictionary[i][j].componentID)
                                {
                                    hasTimeStepData[k] = true;
                                }
                            }
                        }
                    }

                    for (int j = 0; j < hasTimeStepData.Count; j++)
                    {
                        if (hasTimeStepData[j] == false)
                        {
                            Vector2 prevPos = new Vector2();
                            for (int k = 0; k < stepDictionary[i - 1].Count; k++)
                            {
                                if (stepDictionary[i - 1][k].eventType == "M" && stepDictionary[i - 1][k].componentID == threads[j].id)
                                {
                                    prevPos = stepDictionary[i - 1][k].componentPos;
                                }
                            }
                            Vector2 nextPos = prevPos;
                            bool end = false;
                            for (int k = i + 1; k < maxStep+1; k++)
                            {
                                if (stepDictionary.ContainsKey(k))
                                {
                                    for (int l = 0; l < stepDictionary[k].Count; l++)
                                    {
                                        if (stepDictionary[k][l].eventType == "M" && stepDictionary[k][l].componentID == threads[j].id)
                                        {
                                            if (stepDictionary[k][l].componentPos != prevPos)
                                            {
                                                if (Vector2.Distance(prevPos, stepDictionary[k][l].componentPos) > 1 || Vector2.Distance(prevPos, stepDictionary[k][l].componentPos) < -1)
                                                {
                                                    if (k - Mathf.Abs(Vector2.Distance(prevPos, stepDictionary[k][l].componentPos)) == i - 1)
                                                    {
                                                        if (prevPos.x != stepDictionary[k][l].componentPos.x)
                                                        {
                                                            if (prevPos.x > stepDictionary[k][l].componentPos.x)
                                                            {
                                                                nextPos = new Vector2(nextPos.x - 1, nextPos.y);
                                                            }
                                                            else
                                                            {
                                                                nextPos = new Vector2(nextPos.x + 1, nextPos.y);
                                                            }
                                                        }
                                                        else
                                                        {
                                                            if (prevPos.y > stepDictionary[k][l].componentPos.y)
                                                            {
                                                                nextPos = new Vector2(nextPos.x, nextPos.y - 1);
                                                            }
                                                            else
                                                            {
                                                                nextPos = new Vector2(nextPos.x, nextPos.y + 1);
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            end = true;
                                            break;
                                        }
                                    }
                                    if (end == true)
                                    {
                                        break;
                                    }
                                }
                            }

                            StepData newStep = new StepData();
                            newStep.componentID = threads[j].id;
                            newStep.componentPos = nextPos;
                            newStep.eventType = "M";
                            newStep.timeStep = i;

                            stepDictionary[i].Add(newStep);
                        }
                    }
                }
                if (stopwatch.ElapsedMilliseconds > 1000 / 60)
                {
                    stopwatch.Stop();
                    stopwatch.Reset();
                    yield return new WaitForEndOfFrame();
                    stopwatch.Start();
                }
            }

            yield return new WaitForSeconds(1f);
            TimeStepData timeStep = new TimeStepData();
            for (int i = 0; i < lvl.components.Count; i++)
            {
                switch (lvl.components[i].type)
                {
                    case "thread":
                        ThreadData thread = new ThreadData();
                        thread.id = lvl.components[i].id;
                        thread.pos = Vector2.zero;
                        switch (lvl.components[i].configuration.initial_direction)
                        {
                            case "North": thread.rotation = new Vector3(0, 0, 90); break;
                            case "South": thread.rotation = new Vector3(0, 0, -90); break;
                            case "East": thread.rotation = new Vector3(0, 0, 0); break;
                            case "West": thread.rotation = new Vector3(0, 0, 180); break;
                        }
                        timeStep.threads.Add(thread);
                        break;

                    case "pickup":
                        PickupData pickup = new PickupData();
                        pickup.id = lvl.components[i].id;
                        pickup.available = lvl.components[i].configuration.value;
                        timeStep.pickups.Add(pickup);
                        break;

                    case "delivery":
                        DeliveryData delivery = new DeliveryData();
                        delivery.id = lvl.components[i].id;
                        delivery.deliveries = 0;
                        timeStep.deliveryPoints.Add(delivery);
                        break;

                    case "semaphore":
                        SemaphoreData semaphore = new SemaphoreData();
                        semaphore.id = lvl.components[i].id;
                        semaphore.open = lvl.components[i].configuration.value;
                        timeStep.sempahores.Add(semaphore);
                        break;

                    case "conditional":
                        ConditionalData conditional = new ConditionalData();
                        conditional.id = lvl.components[i].id;
                        conditional.current = lvl.components[i].configuration.current;
                        conditional.directions = lvl.components[i].configuration.directions;
                        timeStep.conditionals.Add(conditional);
                        break;

                }
                if (stopwatch.ElapsedMilliseconds > 1000 / 60)
                {
                    stopwatch.Stop();
                    stopwatch.Reset();
                    yield return new WaitForEndOfFrame();
                    stopwatch.Start();
                }
            }

            yield return new WaitForSeconds(1f);
            for (int i = 0; i < stepDictionary.Count; i++)
            {
                if (i != 0)
                {
                    timeStep = timeStep.Copy(timeSteps[i - 1]);
                    timeStep.timeStep = i;
                    timeStep.previousStep = timeSteps[i - 1];
                    timeSteps[i - 1].nextStep = timeStep;
                }
                for (int j = 0; j < stepDictionary[i].Count; j++)
                {
                    switch (stepDictionary[i][j].eventType)
                    {
                        case "M":
                            timeStep.GetThread(stepDictionary[i][j].componentID).pos = stepDictionary[i][j].componentPos;
                            if (i != 0)
                            {
                                Vector2 difference = timeSteps[timeSteps.Count - 1].GetThread(stepDictionary[i][j].componentID).pos - timeStep.GetThread(stepDictionary[i][j].componentID).pos;
                                if (difference.x > 0) { timeStep.GetThread(stepDictionary[i][j].componentID).rotation = new Vector3(0, 0, 180); }
                                else if (difference.x < 0) { timeStep.GetThread(stepDictionary[i][j].componentID).rotation = new Vector3(0, 0, 0); }
                                else if (difference.y > 0) { timeStep.GetThread(stepDictionary[i][j].componentID).rotation = new Vector3(0, 0, 90); }
                                else if (difference.y < 0) { timeStep.GetThread(stepDictionary[i][j].componentID).rotation = new Vector3(0, 0, -90); }
                            }
                            break;
                        case "D":
                            if (stepDictionary[i][j].componentStatus.delivered_to != 0)
                            {
                                timeStep.GetDeliveryPoint(stepDictionary[i][j].componentStatus.delivered_to).deliveries++;
                            }
                            break;
                        case "E":
                            if (timeStep.GetSemaphore(stepDictionary[i][j].componentID) != null)
                            {
                                timeStep.GetSemaphore(stepDictionary[i][j].componentID).open = stepDictionary[i][j].componentStatus.value;
                            }
                            else if (timeStep.GetPickup(stepDictionary[i][j].componentID) != null)
                            {
                                timeStep.GetPickup(stepDictionary[i][j].componentID).available = stepDictionary[i][j].componentStatus.available;
                            }
                            else if (timeStep.GetThread(stepDictionary[i][j].componentID) != null)
                            {
                                if (stepDictionary[i][j].componentStatus.payload != null)
                                {
                                    timeStep.GetThread(stepDictionary[i][j].componentID).DisablePackages();
                                    for (int k = 0; k < stepDictionary[i][j].componentStatus.payload.Length; k++)
                                    {
                                        for (int l = 0; l < i; l++)
                                        {
                                            if (timeSteps[l].GetThread(stepDictionary[i][j].componentID).ContainsPackage(stepDictionary[i][j].componentStatus.payload[k]) == false)
                                            {
                                                PackageData package = new PackageData();
                                                package.active = false;
                                                package.id = stepDictionary[i][j].componentStatus.payload[k];
                                                timeSteps[l].GetThread(stepDictionary[i][j].componentID).packages.Add(package);
                                            }
                                        }
                                        if (timeStep.GetThread(stepDictionary[i][j].componentID).ContainsPackage(stepDictionary[i][j].componentStatus.payload[k]))
                                        {
                                            timeStep.GetThread(stepDictionary[i][j].componentID).GetPackage(stepDictionary[i][j].componentStatus.payload[k]).active = true;
                                        }
                                        else
                                        {
                                            PackageData package = new PackageData();
                                            package.active = true;
                                            package.id = stepDictionary[i][j].componentStatus.payload[k];
                                            timeStep.GetThread(stepDictionary[i][j].componentID).packages.Add(package);
                                        }
                                    }
                                }
                            }
                            else if (timeStep.GetConditional(stepDictionary[i][j].componentID) != null)
                            {
                                if (stepDictionary[i][j].componentStatus.current != -1)
                                {
                                    timeStep.GetConditional(stepDictionary[i][j].componentID).current = stepDictionary[i][j].componentStatus.current;
                                }
                            }
                            break;
                    }
                }
                timeSteps.Add(timeStep);
                if (stopwatch.ElapsedMilliseconds > 1000 / 60)
                {
                    stopwatch.Stop();
                    stopwatch.Reset();
                    yield return new WaitForEndOfFrame();
                    stopwatch.Start();
                }
            }

            playerInteraction.playerInteraction_UI.playbackSlider.maxValue = maxStep;
            playerInteraction.playerInteraction_UI.loadingOverlay.ClosePanel();
            playerInteraction.playerInteraction_UI.playbackControls.gameObject.SetActive(true);
            playerInteraction.playerInteraction_UI.stopSimulationButton.interactable = true;
            playerInteraction.playerInteraction_UI.stopSimulationButton.gameObject.SetActive(true);
            playerInteraction.playerInteraction_UI.pauseSimulationButton.interactable = true;
            playerInteraction.playerInteraction_UI.pauseSimulationButton.gameObject.SetActive(true);
            playerInteraction.playerInteraction_UI.playbackSlider.interactable = true;
            playerInteraction.playerInteraction_UI.playbackSlider.gameObject.SetActive(true);
            yield return PlaySimulation(maxStep);
        }
        else
        {
            yield return null;
        }
    }
コード例 #3
0
        /// <summary>
        /// <para></para>
        /// </summary>
        public GenerateCode()
        {
            // BEGIN AUTO-GENERATED INSTANTIATIONS FOR GenerateCode.xmind
            Apply <IPortConnection, string> getWiringCode = new Apply <IPortConnection, string>()
            {
                InstanceName = "getWiringCode", Lambda = wire => GetWiringCode(wire)
            };
            Apply <VisualPortGraph, IEnumerable <IPortConnection> > id_93847d6aaed2417982f07e3c5ceb7d6c = new Apply <VisualPortGraph, IEnumerable <IPortConnection> >()
            {
                InstanceName = "Default", Lambda = graph => graph.GetConnections()
            };
            Apply <VisualPortGraph, IEnumerable <VisualPortGraphNode> > id_58c0814d58704d2ba3914cb9086e1d4c = new Apply <VisualPortGraph, IEnumerable <VisualPortGraphNode> >()
            {
                InstanceName = "Default", Lambda = graph => graph.GetNodes().Select(n => n as VisualPortGraphNode)
            };
            Apply <VisualPortGraphNode, string> getInstantiationCode = new Apply <VisualPortGraphNode, string>()
            {
                InstanceName = "getInstantiationCode", Lambda = node => GetInstantiationCode(node)
            };
            Collection <string> id_edb65ab7de9643389d7ad3b04e552a23 = new Collection <string>()
            {
                InstanceName = "Default", OutputLength = -2, OutputOnEvent = true
            };
            Collection <string> id_f0164989439c44c69ad7d21790e8b6fe = new Collection <string>()
            {
                InstanceName = "Default", OutputLength = -2, OutputOnEvent = true
            };
            ConditionalData <string> id_4bffda1df55b4072b1d4c5fae8296108 = new ConditionalData <string>()
            {
                InstanceName = "Default", Condition = s => !string.IsNullOrWhiteSpace(s)
            };
            ConditionalData <string> id_cdddd549ddf24caa98e599e12ae9bd4a = new ConditionalData <string>()
            {
                InstanceName = "Default", Condition = s => !string.IsNullOrWhiteSpace(s)
            };
            Data <VisualPortGraph> id_02492ace575b4661a828cda6c3ae4513 = new Data <VisualPortGraph>()
            {
                InstanceName = "Default", Lambda = GetGraph
            };
            Data <VisualPortGraph> id_6da14dcf73384827ba2a82ae293841d5 = new Data <VisualPortGraph>()
            {
                InstanceName = "Default", Lambda = GetGraph
            };
            ForEach <IPortConnection> id_2964f2d203b64e86b40148d73196645d = new ForEach <IPortConnection>()
            {
                InstanceName = "Default"
            };
            ForEach <VisualPortGraphNode> id_153c3759698e4ce889f4782c9d76d418 = new ForEach <VisualPortGraphNode>()
            {
                InstanceName = "Default"
            };

            // END AUTO-GENERATED INSTANTIATIONS FOR GenerateCode.xmind

            // BEGIN AUTO-GENERATED WIRING FOR GenerateCode.xmind
            startConnector.WireTo(id_6da14dcf73384827ba2a82ae293841d5, "fanoutList");                              // (@EventConnector (startConnector).fanoutList) -- [IEvent] --> (Data<VisualPortGraph> (id_6da14dcf73384827ba2a82ae293841d5).start)
            startConnector.WireTo(id_02492ace575b4661a828cda6c3ae4513, "fanoutList");                              // (@EventConnector (startConnector).fanoutList) -- [IEvent] --> (Data<VisualPortGraph> (id_02492ace575b4661a828cda6c3ae4513).start)
            id_6da14dcf73384827ba2a82ae293841d5.WireTo(id_58c0814d58704d2ba3914cb9086e1d4c, "dataOutput");         // (Data<VisualPortGraph> (id_6da14dcf73384827ba2a82ae293841d5).dataOutput) -- [IDataFlow<VisualPortGraph>] --> (Apply<VisualPortGraph,IEnumerable<VisualPortGraphNode>> (id_58c0814d58704d2ba3914cb9086e1d4c).input)
            id_58c0814d58704d2ba3914cb9086e1d4c.WireTo(id_153c3759698e4ce889f4782c9d76d418, "output");             // (Apply<VisualPortGraph,IEnumerable<VisualPortGraphNode>> (id_58c0814d58704d2ba3914cb9086e1d4c).output) -- [IDataFlow<IEnumerable<VisualPortGraphNode>>] --> (ForEach<VisualPortGraphNode> (id_153c3759698e4ce889f4782c9d76d418).collectionInput)
            id_153c3759698e4ce889f4782c9d76d418.WireTo(getInstantiationCode, "elementOutput");                     // (ForEach<VisualPortGraphNode> (id_153c3759698e4ce889f4782c9d76d418).elementOutput) -- [IDataFlow<VisualPortGraphNode>] --> (Apply<VisualPortGraphNode,string> (getInstantiationCode).input)
            id_153c3759698e4ce889f4782c9d76d418.WireTo(id_edb65ab7de9643389d7ad3b04e552a23, "complete");           // (ForEach<VisualPortGraphNode> (id_153c3759698e4ce889f4782c9d76d418).complete) -- [IEvent] --> (Collection<string> (id_edb65ab7de9643389d7ad3b04e552a23).clearList)
            getInstantiationCode.WireTo(id_4bffda1df55b4072b1d4c5fae8296108, "output");                            // (Apply<VisualPortGraphNode,string> (getInstantiationCode).output) -- [IDataFlow<string>] --> (ConditionalData<string> (id_4bffda1df55b4072b1d4c5fae8296108).input)
            id_4bffda1df55b4072b1d4c5fae8296108.WireTo(id_edb65ab7de9643389d7ad3b04e552a23, "conditionMetOutput"); // (ConditionalData<string> (id_4bffda1df55b4072b1d4c5fae8296108).conditionMetOutput) -- [IDataFlow<string>] --> (Collection<string> (id_edb65ab7de9643389d7ad3b04e552a23).element)
            id_edb65ab7de9643389d7ad3b04e552a23.WireTo(instantiationLinesOutputConnector, "listOutput");           // (Collection<string> (id_edb65ab7de9643389d7ad3b04e552a23).listOutput) -- [IDataFlow<List<string>>] --> (@DataFlowConnector<List<string>> (instantiationLinesOutputConnector).dataInput)
            id_02492ace575b4661a828cda6c3ae4513.WireTo(id_93847d6aaed2417982f07e3c5ceb7d6c, "dataOutput");         // (Data<VisualPortGraph> (id_02492ace575b4661a828cda6c3ae4513).dataOutput) -- [IDataFlow<VisualPortGraph>] --> (Apply<VisualPortGraph,IEnumerable<IPortConnection>> (id_93847d6aaed2417982f07e3c5ceb7d6c).input)
            id_93847d6aaed2417982f07e3c5ceb7d6c.WireTo(id_2964f2d203b64e86b40148d73196645d, "output");             // (Apply<VisualPortGraph,IEnumerable<IPortConnection>> (id_93847d6aaed2417982f07e3c5ceb7d6c).output) -- [IDataFlow<IEnumerable<IPortConnection>>] --> (ForEach<IPortConnection> (id_2964f2d203b64e86b40148d73196645d).collectionInput)
            id_2964f2d203b64e86b40148d73196645d.WireTo(getWiringCode, "elementOutput");                            // (ForEach<IPortConnection> (id_2964f2d203b64e86b40148d73196645d).elementOutput) -- [IDataFlow<IPortConnection>] --> (Apply<IPortConnection,string> (getWiringCode).input)
            id_2964f2d203b64e86b40148d73196645d.WireTo(id_f0164989439c44c69ad7d21790e8b6fe, "complete");           // (ForEach<IPortConnection> (id_2964f2d203b64e86b40148d73196645d).complete) -- [IEvent] --> (Collection<string> (id_f0164989439c44c69ad7d21790e8b6fe).clearList)
            getWiringCode.WireTo(id_cdddd549ddf24caa98e599e12ae9bd4a, "output");                                   // (Apply<IPortConnection,string> (getWiringCode).output) -- [IDataFlow<string>] --> (ConditionalData<string> (id_cdddd549ddf24caa98e599e12ae9bd4a).input)
            id_cdddd549ddf24caa98e599e12ae9bd4a.WireTo(id_f0164989439c44c69ad7d21790e8b6fe, "conditionMetOutput"); // (ConditionalData<string> (id_cdddd549ddf24caa98e599e12ae9bd4a).conditionMetOutput) -- [IDataFlow<string>] --> (Collection<string> (id_f0164989439c44c69ad7d21790e8b6fe).element)
            id_f0164989439c44c69ad7d21790e8b6fe.WireTo(wiringLinesOutputConnector, "listOutput");                  // (Collection<string> (id_f0164989439c44c69ad7d21790e8b6fe).listOutput) -- [IDataFlow<List<string>>] --> (@DataFlowConnector<List<string>> (wiringLinesOutputConnector).dataInput)
            // END AUTO-GENERATED WIRING FOR GenerateCode.xmind

            // BEGIN MANUAL INSTANTIATIONS FOR GenerateCode.xmind
            // END MANUAL INSTANTIATIONS FOR GenerateCode.xmind

            // BEGIN MANUAL WIRING FOR GenerateCode.xmind
            // END MANUAL WIRING FOR GenerateCode.xmind
        }