Questo sito utilizza cookies, anche di terze parti, per mostrare pubblicità e servizi in linea con il tuo account. Leggi l'informativa sui cookies.
Username: Password: oppure
C# / VB.NET - Consigli sui cicli
Forum - C# / VB.NET - Consigli sui cicli

Avatar
Thejuster (Member)
Guru^2


Messaggi: 1671
Iscritto: 04/05/2008

Segnala al moderatore
Postato alle 12:55
Domenica, 17/04/2016
Ragazzi durante il parsing di alcuni elementi sempre inerenti al mio progetto,
effettuando dei test mi sono reso conto di una casa.
Magari potete darmi consigli o aiuti su come impostare la cosa.
Perché mi sembra molto articolata come funzione.

vi spiego.

Fin quando dò la possibilità all'utente di fare qualcosa del genere.

http://www.makerando.com/forum/uploads/imgs/pre_1460889452 ...

mi viene molto facile gestire tutti gli elementi in connessioni

I moduli li ho resi come IEnumerable.
con la possibilità di sapere quante connessioni ci sono,
sia Input che Output.

I colori sono tipicizzati nel senso



connection.type.GetType() == typeof(Bool)  - >  Fucsia



per recuperare i valori, titolo, funzione, posizione ecc. ecc.
mi basta accedere ovviamente alla lista.
che hai anche i seguenti metodi



Nodo.Connesioni<ConnessioniNodi>()[0].To.Nodo.Title;
Nodo.Connesioni<ConnessioniNodi>()[0].From.Nodo.Title;



In questo modo posso sapere dove e a quale elemento và a connettersi

Con questo un algoritmo riesco a recuperare in sequenza perfetta tutti i nodi collegati in entrata ed uscita.
Il ciclo si ripete fin quando tutti i nodi non sono stati letti.
Dal primo all'ultimo.


Ora il problema, dubbio mi viene quando faccio qualcosa del genere.

http://www.makerando.com/forum/uploads/imgs/pre_1460890018 ...

vi ho tracciato in nodi con un rettangolo rosso.
Dalla screen notate che il modulo Mostra Scelta, effettua delle diramazioni.
che a sua volta porta ad un'altro modulo che effettua altre diramazioni.

come potrei gestire la cosa?
Sto avendo seri dubbi sul sistema.

Mi consigliate di creare un nuovo void al qualche il modulo Mostra scelta esegue dei cicli per ogni collegamento output che ha?

E' meglio scrivere tutto in un solo void, o separare i cicli da funzione a funzione?

non sò quale metodo sia buono, e quale sia funzionale...
se inverto caso mai un ordine mi ritroverei del codice generato in LUA a casaccio.

Ultima modifica effettuata da Thejuster il 18/04/2016 alle 8:36


PM Quote
Avatar
pierotofy (Admin)
Guru^2


Messaggi: 6097
Iscritto: 04/12/2003

Segnala al moderatore
Postato alle 2:22
Lunedì, 18/04/2016
TheJuster, siccome le queste domande sono molto specifiche, persone che non hanno molta familiarità con il tuo progetto avranno difficoltà a risponderti (io incluso).

1. Usa un titolo descrittivo nel topic che riassuma la tua domanda.
2. Fornisci una descrizione concisa del problema.
3. Formula la domanda in maniera chiara.
4. Se ci sono domande multiple, valuta se è il caso di aprire più topics (uno per ogni domanda).

:ot:


Seguimi su Twitter: http://www.twitter.com/pierotofy

Fai quello che ti piace, e fallo bene.
PM Quote
Avatar
Thejuster (Member)
Guru^2


Messaggi: 1671
Iscritto: 04/05/2008

Segnala al moderatore
Postato alle 8:55
Lunedì, 18/04/2016
Si hai ragione piero scusami.
Sono stato troppo diretto.

Vi mostro il codice.

anche se credo che il sistema non sia corretto.

Parte 1:

Inizialmente, si ha un nodo chiamato Avvio.
Questo nodo ha una sola uscita (Output) di cui una sola connessione che successivamente,
punterà ad un altro nodo.

quindi la prima cosa logica che mi è venuta in mente, e quella di andare diretto cercando con un ciclo
il primo nodo con cui il titolo è chiamato Avvio.

come in questo in questo esempio.

Codice sorgente - presumibilmente C++

  1. public void ProcessaCodice()
  2. {
  3.  
  4. //In primis,
  5. //Prendo il primo modulo dove inizia il tutto
  6.  //ovvero il modulo Avvio.
  7.  
  8. Node avvio = new Node("test"); /*Nodo Temporaneo */
  9.  
  10.  
  11. for (int i = 0; i < grafico.graphNodes.Count; i++)
  12.             {
  13.                 if (grafico.graphNodes[i].Title.ToString().Trim() == "Avvio")
  14.                 {
  15.  
  16.                     //Trovato il nodo avvio, lo imposto nella variabile nodo dichiarata sopra.
  17.                     //per poter proseguire successivamente.
  18.                     avvio = grafico.graphNodes[i];
  19.                 }
  20.             }
  21.  
  22.  
  23. /*Recuperato il primo modulo, vediamo successivamente a quale punta.
  24.              * normalmente il modulo avvio ha una sola uscita.
  25.              * quindi può puntare ad un solo elemento
  26.              vediamo dunque il modulo avvio cosa attiva.*/
  27.  
  28.  
  29. //Se il nodo recuperato (Avvio), nelle connessioni,
  30. //Come detto ne ha solo una, quindi 0 va a puntare il nodo Dialogo...
  31.  
  32. if (avvio.Connections.ToList<NodeConnection>()[0].To.Node.Title == "Dialogo")
  33.             {
  34.                 //Creo la riga del codice LUA mediante la funzione del nodo
  35.                 CreateLuaCode(avvio.Connections.ToList<NodeConnection>()[0].To.Node.Funzione + "\n");
  36.                
  37.                 //Chiamo la funzione dialogo per proseguire avanti.
  38.                 Cod_Dialogo(avvio);
  39.             }
  40.  
  41.  
  42. }




Fin qui si è capito.
Nel senso che ho fatto in questo modo.

Se:

Avvio -> Dialogo

Se il nodo Avvio punta al nodo Dialogo, crea la funzione lua,
e successivamente va a chiamare un'altro void per continuare con la funzione del dialogo.



Parte 2: Funzione Dialogo

Codice sorgente - presumibilmente C# / VB.NET

  1. //Da qui si presume che ora siamo al secondo nodo
  2.       //Se esso è un nodo di tipo "Dialogo" altrimenti la funzione poteva essere diversa tipo
  3.      //Mostra scelta o ecc..
  4.      //Come riferimento gli passo come nodo AVVIO negli argomenti.
  5.  
  6.       public void Cod_Dialogo(Node avvio)
  7.         {
  8.  
  9.             /* Recperiamo il modulo che avvio ha attivato */
  10.             Node prossimo = new Node("");
  11.  
  12.  
  13.             prossimo = avvio.Connections.ToList<NodeConnection>()[0].To.Node;
  14.  
  15.  
  16.             for (int i = 1; i < Inserimenti.Count; i++)
  17.             {
  18.                 /*Se questo modulo attiva un dialogo*/
  19.                 if (prossimo.Connections.ToList<NodeConnection>()[0].To.Node.Title == "Dialogo")
  20.                 {
  21.                     /* L'ultima connessione è sempre quella che attiverà il modulo successivo
  22.                      * mentre la prima e sempre quella da cui viene attivato (Guardate Screen)*/
  23.  
  24.                     int connessioni = prossimo.Connections.ToList<NodeConnection>().Count - 1;
  25.                     MessageBox.Show("Il modulo " + prossimo.Title + " Attiva : " + prossimo.Connections.ToList<NodeConnection>()[connessioni].To.Node.Title);
  26.  
  27.                     //codice
  28.                     add_code("Function " + prossimo.Funzione + "\n\n");
  29.                     add_code("Dialog('blablabla')\n\n");
  30.                     add_code(prossimo.Connections.ToList<NodeConnection>()[prossimo.Connections.ToList<NodeConnection>().Count - 1].To.Node.Funzione + "\n\n");
  31.  
  32.                     add_code("end\n\n");
  33.  
  34.                     //riparto da qui
  35.  
  36.                     prossimo = prossimo.Connections.ToList<NodeConnection>()[prossimo.Connections.ToList<NodeConnection>().Count - 1].To.Node;
  37.  
  38.                 }
  39.  
  40.             }
  41.         }




In questa parte credo che ci sia confusione,
Non se sono convinto ma credo che il funzionamento sia anomalo.
Anche se funziona, ho la strana sensazione che sia scritto male.


La variabile nel ciclo "Inserimenti" Sarebbe una sorta di contatore dei nodi inseriti.
però quel ciclo poco mi convince.

anzi credo che sia proprio sbagliato usare quel ciclo.

In realtà dovrebbe essere una sorta di catena.

Avvio -> Dialogo -> Dialogo -> Dialogo -> Altro -> Altro Ancora.

del tipo,
Se questo nodo, punta ad un altro nodo che si chiama "Bla bla bla"
Chiama questo void e continua.

Lo stesso dovrebbe fare il void successivo.


Per l'altro problema.
Se invece abbiamo una diramazione come nell'altra screen,
Come la mettiamo?
Una volta che sono andato avanti, continuando connessione per connessione,
Come ritorno indietro e proseguire continuando con le altre connessioni?

non sò se mi sono spiegato bene.
ma spero di sì. 8-|


Il risultato alla fine della funzione è questo:

http://www.makerando.com/forum/uploads/imgs/pre_1460963084 ...

Ora anche se stranamente funziona, ed il codice sopra al secondo void mi sembra scorretto,
successivamente se vorrei ottenere qualcosa del genere:

http://www.makerando.com/forum/uploads/imgs/pre_1460890018 ...

Man mano che avanzo nei nodi, come torno indietro e poi continuare con le altre diramazioni?

Ultima modifica effettuata da Thejuster il 18/04/2016 alle 9:06


PM Quote
Avatar
pierotofy (Admin)
Guru^2


Messaggi: 6097
Iscritto: 04/12/2003

Segnala al moderatore
Postato alle 15:31
Lunedì, 18/04/2016
Mi sembra una classica applicazione di DFS: https://en.wikipedia.org/wiki/Depth-first_search#Pseudocode

Usa la versione non ricorsiva usando uno stack.

G e' la lista di nodi. I vertici V sono le tue Connections.

Non ti serve tenere traccia di quali vertici hai visitato, siccome il tuo grafo non ha cicli.

All'inizio il tuo stack conterra' solo il nodo avvio. Man mano che esplori i nodi nuovi, li aggiungi allo stack.

Prova ad implementarlo, se poi hai domande chiedi pure (posta nuovamente il codice).

Ultima modifica effettuata da pierotofy il 18/04/2016 alle 15:35


Seguimi su Twitter: http://www.twitter.com/pierotofy

Fai quello che ti piace, e fallo bene.
PM Quote
Avatar
Thejuster (Member)
Guru^2


Messaggi: 1671
Iscritto: 04/05/2008

Segnala al moderatore
Postato alle 9:54
Mercoledì, 12/07/2017
Anche se il topic è dello scorso anno
ed avevo momentaneamente interrotto il progetto.

Sono arrivato al dunque di completare questo processo.
è qui mi serviva un pò di aiuto sul fattore logico della cosa.

Riprendo il topic senza crearne uno nuovo.

Quello che dovrei fare, è una sorta come il Blue Print di Unreal Engine.
La domanda è:

Come posso creare un parsing basandomi su una struttura a nodi?

L'obiettivo dell'editor è quello di generare codice Javascript basandosi
sui collegamenti creati dall'utente.

Ma la forza dell'editor è la possibilità di permettere all'utente di realizzare propri blocchi ( Nodi )
personali e renderli come dei Prefabs ( Prefabbricati )


Se prendo esempio

http://www.makerando.com/forum/uploads/imgs/pre_1460733688 ...

Ho svariate deviazioni che si comportano come un if then else.

Un idea, e quella di assegnare ad ogni Nodo una funzione.
Del tipo ogni nodi presente è una funzione.


Codice Generato di esempio:

Codice sorgente - presumibilmente C# / VB.NET

  1. function Event0001(){
  2.  
  3. }
  4.  
  5. inherit(SceneGame, Core);
  6.  
  7. //Nodo Avvio
  8. //Il programma vede il Continue a quale nodo è collegato
  9. //Guardando la screen il nodo Start è collegato
  10. //ad un'altro nodo chiamato "Dialogo"
  11. Event0001.prototype.start = function()
  12. {
  13.      Event0001.mod1(); //Chiamo il dialogo
  14. }
  15.  
  16.  
  17.  
  18. Event001.prototype.mod1()
  19. {
  20.  
  21.    Dialog("Ciao come va?");
  22.  
  23. }





La logica che ho fatto è più o meno questa

All'inizio, quando in parsing entra in anzione,
si ha qualcosa del genere



Codice sorgente - presumibilmente C# / VB.NET

  1. function Event0001(){
  2.  
  3. }
  4.  
  5. inherit(SceneGame, Core);
  6.  
  7.  
  8.  
  9.  
  10. Event0001.prototype.start = function()
  11. {
  12.  
  13.    //Primo Step del parser
  14.    //Si ferma con la funzione incompleta
  15.    //Vendendo dove il nodo Inizia va a collegarsi





successivamente completa la funziona

Codice sorgente - presumibilmente C# / VB.NET

  1. Event0001.prototype.start = function()
  2. {
  3.  
  4.    //Primo Step del parser
  5.    //Si ferma con la funzione incompleta
  6.    //Vendendo dove il nodo Inizia va a collegarsi
  7.    
  8.    Event0001.mod1(); //Chiamo il dialogo
  9.  
  10. }
  11.  
  12.  
  13. //Continuo con la lettura degli altri nodi





Fin quando parto da un singolo nodo, e via via.
Non ho problemi.

Dove sorge il mio problema?


supponiamo che io abbia una struttura del genere


Codice sorgente - presumibilmente Plain Text

  1. [H]-----[I]
  2.                                                           |
  3.                          |------[C]----[D]-----[E]------[F]            
  4. [Inizio]  ---  [A]--
  5.                          |_____[B]___[G]



Il parser non và tramite ID ma tramite le connessioni che si susseguono.
Se ogni nodo esempio, avrebbe più di una diramazione.
Arrivato al nodo F come faccio a sapere che deve tornare in dietro e proseguire per le altre diramazioni?
e che non deve ricalcolare tutto il nodo ma unicamente l'altra diramazione e generarne il codice
in quel pezzo già scritto?

E' questo il mio dilemma.

Come detto prima, il parser genera via via funzioni e metodi man mano che prosegue verso gli altri nodi.
Ma come tornare indietro e modificare quella linea generata aggiungendo altre chiamate?


Se il parser ha già scritto questo

Codice sorgente - presumibilmente Plain Text

  1. Event0001.prototype.start = function()
  2. {
  3.  
  4.  
  5.    Event0001.mod1(); //Chiamo il dialogo
  6.  
  7. }




Come faccio ad inserire ulteriore testo in quella funzione già scritta?



Questa è una piccolissima parte della creazione e gestione dei nodi.

Codice sorgente - presumibilmente C#

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Threading.Tasks;
  6. using Mire_Node;
  7. using Mire_Node.Core;
  8. using Mire_Editor;
  9.  
  10.  
  11.  /*#################################################*/
  12. /* #  (C) Copyright Making Italia 2017 - Mire Engine                                    #*/
  13. /* #  It is strictly forbidden to even partially copy the content of this source. #*/
  14. /* #The source is protected under copyright Making Italy trademark filed and #*/
  15. /* # registered. Violation of EULA agreements will be punishable by civil or     #*/
  16. /* # penalties with the maximum applicable law.                                           #*/
  17. /* #################################################*/
  18.  
  19.  
  20. namespace MireEditor.Nodes
  21. {
  22.     [Serializable]
  23.     public static class NodeList
  24.     {
  25.         static Dictionary<string, Type> nodes = new Dictionary<string, Type>() {
  26.                 { "fx|dialog", typeof(NodeDialog) },
  27.                 { "fx|setvariable", typeof(NodeVariable) },
  28.                 { "int|numberconstant", typeof(NodeNumberConstant) },
  29.                 { "fx|getvariable", typeof(NodeGetVariable) },
  30.                 { "int|operation", typeof(NodeNumericOperator) },
  31.                 { "brn|else", typeof(NodeBranch) },
  32.                 { "int|comparison", typeof(NodeComparison) }
  33.             };
  34.  
  35.         static Dictionary<Type, object> tagType = new Dictionary<Type, object>() {
  36.             { typeof(string), "" },
  37.             { typeof(int), 0},
  38.             { typeof(bool), new Point(0,0) },
  39.             { typeof(Image), 0f },
  40.             { typeof(NodeConnector), true }
  41.         };
  42.  
  43.         public static Node GetNodeFromString(string s)
  44.         {
  45.             return (Node)Activator.CreateInstance(nodes[s]);
  46.         }
  47.          
  48.         public static string[] GetNodeCodes()
  49.         {
  50.             return nodes.Select(x => x.Key).ToArray();
  51.         }
  52.  
  53.         public static object FlagFromType(Type type)
  54.         {
  55.             return tagType[type];
  56.         }
  57.     }
  58.  
  59.     [Serializable]
  60.     public abstract class NodeBase : Node
  61.     {
  62.         public int? StartIndex;
  63.         public int? ContinueIndex;
  64.         public int? ModeIndex;
  65.  
  66.         //Dictionary<int, int> ItemDict;
  67.         Dictionary<int, Tuple<int, Type>> Inputs;
  68.         Dictionary<int, Tuple<int, Type>> Outputs;
  69.  
  70.         public NodeBase(string title) : base(Program.GetString(title))
  71.         {
  72.             Inputs = new Dictionary<int, Tuple<int, Type>>();
  73.             Outputs = new Dictionary<int, Tuple<int, Type>>();
  74.         }
  75.  
  76.         public bool HasStart()
  77.         {
  78.             return StartIndex.HasValue;
  79.         }
  80.  
  81.  
  82.         public void AddStart()
  83.         {
  84.             StartIndex = nodeItems.Count;
  85.             AddItem(new NodeLabelItem(Program.GetString("node_start"), true, false) { Tag = false });
  86.         }
  87.          
  88.         public void AddContinue()
  89.         {
  90.             ContinueIndex = nodeItems.Count;
  91.             AddItem(new NodeLabelItem(Program.GetString("node_continue"), false, true) { Tag = true });
  92.  
  93.         }
  94.  
  95.         public void AddInput(Type inType, string unlocalizedInputName, int index)
  96.         {
  97.             Inputs.Add(index, new Tuple<int, Type>(nodeItems.Count, inType));
  98.  
  99.             object it = NodeList.FlagFromType(inType);
  100.  
  101.             if (inType == typeof(string) || inType == typeof(int))
  102.                 AddItem(new NodeTextBoxItem(Program.GetString(unlocalizedInputName), true, false) { Tag = it });
  103.             else if (inType == typeof(Image)) {
  104.                 var image = new NodeImageItem(MireEditor.Properties.Resources.faccia_vuota, false, false);
  105.                 image.Clicked += new EventHandler<NodeItemEventArgs>(OnImgClicked);
  106.                 AddItem(image);
  107.             }
  108.         }
  109.  
  110.         public void AddMode(string[] modes)
  111.         {
  112.             ModeIndex = nodeItems.Count;
  113.             AddItem(new NodeDropDownItem(modes, 0, false, false)); // FIXME: FUNZIONA SOLO CON NODI CON UN MODO
  114.         }
  115.  
  116.         public string GetMode()
  117.         {
  118.             if (ModeIndex == null)
  119.                 throw new Exception();
  120.             else
  121.             {
  122.                 NodeDropDownItem ni = (NodeDropDownItem)nodeItems[ModeIndex.Value];
  123.                 return ni.Items[ni.SelectedIndex];
  124.             }
  125.         }
  126.  
  127.         protected virtual void OnImgClicked(object sender, NodeItemEventArgs e)
  128.         {
  129.  
  130.         }
  131.  
  132.         public void AddOutput(Type outType, string unlocalizedOutputName, int index)
  133.         {
  134.             object ot = NodeList.FlagFromType(outType);
  135.             Outputs.Add(index, new Tuple<int, Type>(nodeItems.Count, outType));
  136.             AddItem(new NodeLabelItem(Program.GetString(unlocalizedOutputName), false, true) { Tag = ot });
  137.         }
  138.  
  139.         public NodeItem GetStart()
  140.         {
  141.             if (StartIndex == null)
  142.                 return null;
  143.  
  144.             return nodeItems[StartIndex.Value];
  145.         }
  146.  
  147.         public NodeItem GetContinue()
  148.         {
  149.             if (ContinueIndex == null)
  150.                 return null;
  151.             return nodeItems[ContinueIndex.Value];
  152.         }
  153.  
  154.         public string GetInputCode(int index)
  155.         {
  156.             NodeItem ni = nodeItems[Inputs[index].Item1];
  157.             NodeConnection find = connections.Where(x => x.To.Item == ni).FirstOrDefault();
  158.  
  159.             if (find != null)
  160.                 return ((NodeBase)find.From.Node).GetCode(0); // FIXME: FUNZIONA SOLO PER NODI A SINGOLO OUTPUT
  161.              
  162.  
  163.             int parseOut;
  164.  
  165.  
  166.             if (Inputs[index].Item2 == typeof(int))
  167.             {
  168.                 if (int.TryParse(((NodeTextBoxItem)ni).Text, out parseOut))
  169.                     return parseOut.ToString();
  170.                 else
  171.                     throw new NoInputException();
  172.             }
  173.             else if (Inputs[index].Item2 == typeof(string))
  174.             {
  175.                 return ((NodeTextBoxItem)ni).Text;
  176.             }
  177.  
  178.             return "";
  179.         }
  180.  
  181.         public NodeBase GetNextNode()
  182.         {
  183.             if (ContinueIndex == null)
  184.                 return null;
  185.  
  186.             IEnumerable<NodeConnection> con = connections.Where(x => x.From.Item == GetContinue());
  187.  
  188.             if (con.Count() < 1)
  189.                 return null;
  190.  
  191.             return (NodeBase)con.FirstOrDefault().To.Node;
  192.         }
  193.  
  194.         public abstract string GetCode(int index);
  195.  
  196.     }
  197.  
  198.     [Serializable]
  199.     public class NodeStart : NodeBase
  200.     {
  201.         public NodeStart() : base("node_start_title")
  202.         {
  203.             AddContinue();
  204.         }
  205.  
  206.         public override string GetCode(int index)
  207.         {
  208.             return "";
  209.         }
  210.     }
  211.  
  212.     [Serializable]
  213.     public class NodeDialog : NodeBase
  214.     {
  215.         public NodeDialog() : base("node_dialog_title")
  216.         {
  217.             AddStart();
  218.             /*
  219.             AddTextbox("node_dialog_first", true, false, "", 0);
  220.             AddTextbox("node_dialog_second", true, false, "", 1);
  221.             AddTextbox("node_dialog_third", true, false, "", 2);
  222.             AddTextbox("node_dialog_fourth", true, false, "", 3);
  223.  
  224.             var image = new NodeImageItem(MireEditor.Properties.Resources.faccia_vuota, false, false);
  225.             image.Clicked += new EventHandler<NodeItemEventArgs>(OnImgClicked);
  226.             this.AddItem(image);
  227.  
  228.             AddLabel("node_dialog_face", true, false, 1f, 5);
  229.             */
  230.  
  231.  
  232.             AddInput(typeof(string), "node_dialog_first", 0);
  233.             AddInput(typeof(string), "node_dialog_second", 1);
  234.             AddInput(typeof(string), "node_dialog_third", 2);
  235.             AddInput(typeof(string), "node_dialog_fourth", 3);
  236.  
  237.             AddInput(typeof(Image), "", 4);
  238.  
  239.             AddContinue();
  240.         }
  241.  
  242.         protected override void OnImgClicked(object sender, NodeItemEventArgs e)
  243.         {
  244.             //TODO: Implementare il dialogo Seleziona Faccia o Immagine da mostrare
  245.             System.Windows.Forms.MessageBox.Show("Choose Faceset");
  246.         }
  247.  
  248.         public override string GetCode(int index)
  249.         {
  250.             return "";
  251.         }
  252.     }
  253.  
  254.     [Serializable]
  255.     public class NodeVariable : NodeBase
  256.     {
  257.         public NodeVariable() : base("node_setvariable_title")
  258.         {
  259.             AddStart();
  260.  
  261.             AddInput(typeof(string), "node_setvariable_id", 0);
  262.             AddInput(typeof(int), "node_setvariable_value", 1);
  263.             AddMode(new string[5] { "=", "+=", "-=", "*=", "/=" });
  264.  
  265.             AddContinue();
  266.         }
  267.  
  268.         public override string GetCode(int index)
  269.         {
  270.             return string.Format("SETGLOBAL {0} to {1}", GetInputCode(0), GetInputCode(1));
  271.         }
  272.     }
  273.  
  274.     [Serializable]
  275.     public class NodeNumberConstant : NodeBase
  276.     {
  277.         public NodeNumberConstant() : base("node_constant_title")
  278.         {
  279.             AddInput(typeof(int), "node_constant_value", 0);
  280.  
  281.             AddOutput(typeof(int), "node_continue", 0);
  282.         }
  283.  
  284.         public override string GetCode(int index)
  285.         {
  286.             return GetInputCode(0);
  287.         }
  288.     }
  289.  
  290.     [Serializable]
  291.     public class NodeGetVariable : NodeBase
  292.     {
  293.         public NodeGetVariable() : base("node_getvariable_title")
  294.         {
  295.             AddInput(typeof(string), "node_getvariable_value", 0);
  296.  
  297.             AddOutput(typeof(int), "node_continue", 0);
  298.         }
  299.  
  300.         public override string GetCode(int index)
  301.         {
  302.             return GetInputCode(0);
  303.         }
  304.     }
  305.  
  306.  
  307.     [Serializable]
  308.     public class NodeNumericOperator : NodeBase
  309.     {
  310.         public NodeNumericOperator() : base("node_numericoperator_title")
  311.         {
  312.             AddInput(typeof(int), "node_numericoperator_value1", 0);
  313.             AddInput(typeof(int), "node_numericoperator_value2", 1);
  314.             AddMode(new string[4] { "+", "-", "*", "/" });
  315.  
  316.             AddOutput(typeof(int), "node_continue", 0);
  317.         }
  318.  
  319.         public override string GetCode(int index)
  320.         {
  321.             return GetInputCode(0) + GetMode() + GetInputCode(1);
  322.         }
  323.     }
  324.  
  325.  
  326.     [Serializable]
  327.     public class NodeBranch : NodeBase
  328.     {
  329.         public NodeBranch() : base("node_branch_title")
  330.         {
  331.             AddStart();
  332.             /*AddTextbox("node_branch_condition", true, false, new Point(0,0), 0); // CAMBIARE
  333.             AddLabel("node_branch_then", false, true, true, 1);
  334.             AddLabel("node_branch_else", false, true, true, 2);*/
  335.             AddContinue();
  336.         }
  337.  
  338.         public override string GetCode(int index)
  339.         {
  340.             throw new NotImplementedException();
  341.         }
  342.     }
  343.  
  344.     [Serializable]
  345.     public class NodeComparison : NodeBase
  346.     {
  347.         public NodeComparison() : base("node_comparison_title")
  348.         {/*
  349.             AddTextbox("node_comparison_value1", true, false, 0, 0);
  350.             AddTextbox("node_comparison_value2", true, false, 0, 1);
  351.             AddDropdown(new string[5] { "==", "<", ">", "<=", ">=" }, false, false, 0, 2);
  352.             */
  353.  
  354.             AddInput(typeof(int), "node_comparison_value1", 0);
  355.             AddInput(typeof(int), "node_comparison_value2", 1);
  356.             AddMode(new string[1] { "=" });
  357.  
  358.             AddOutput(typeof(bool), "node_continue", 0);
  359.         }
  360.  
  361.         public override string GetCode(int index)
  362.         {
  363.             return GetInputCode(0) + GetMode() + GetInputCode(1);
  364.         }
  365.     }
  366.  
  367.     [Serializable]
  368.     public class NoInputException : Exception
  369.     {
  370.  
  371.     }
  372. }





Parte chiamante


Codice sorgente - presumibilmente C#

  1. private List<string> GenerateCode(NodeBase currentNode)
  2.         {
  3.             string code = (currentNode).GetCode(0);
  4.  
  5.             List<string> cd = new List<string>();
  6.              
  7.             cd.Add(code);
  8.             NodeBase nb = currentNode.GetNextNode();
  9.             if (nb != null)
  10.                 cd = cd.Concat(GenerateCode(nb)).ToList();
  11.  
  12.             Console.WriteLine("Node: " + code);
  13.             Console.WriteLine("Cd Length: " + cd.Count);
  14.  
  15.             return cd;
  16.         }





PM Quote