Questo sito utilizza cookies solo per scopi di autenticazione sul sito e nient'altro. Nessuna informazione personale viene tracciata. Leggi l'informativa sui cookies.
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.
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.
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
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).
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.
//Chiamo la funzione dialogo per proseguire avanti.
Cod_Dialogo(avvio);
}
}
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
//Da qui si presume che ora siamo al secondo nodo
//Se esso è un nodo di tipo "Dialogo" altrimenti la funzione poteva essere diversa tipo
//Mostra scelta o ecc..
//Come riferimento gli passo come nodo AVVIO negli argomenti.
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?
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 )
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
function Event0001(){
}
inherit(SceneGame, Core);
//Nodo Avvio
//Il programma vede il Continue a quale nodo è collegato
//Guardando la screen il nodo Start è collegato
//ad un'altro nodo chiamato "Dialogo"
Event0001.prototype.start = function()
{
Event0001.mod1(); //Chiamo il dialogo
}
Event001.prototype.mod1()
{
Dialog("Ciao come va?");
}
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
function Event0001(){
}
inherit(SceneGame, Core);
Event0001.prototype.start = function()
{
//Primo Step del parser
//Si ferma con la funzione incompleta
//Vendendo dove il nodo Inizia va a collegarsi
successivamente completa la funziona
Codice sorgente - presumibilmente C# / VB.NET
Event0001.prototype.start = function()
{
//Primo Step del parser
//Si ferma con la funzione incompleta
//Vendendo dove il nodo Inizia va a collegarsi
Event0001.mod1(); //Chiamo il dialogo
}
//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
[H]-----[I]
|
|------[C]----[D]-----[E]------[F]
[Inizio] --- [A]--
|_____[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
Event0001.prototype.start = function()
{
Event0001.mod1(); //Chiamo il dialogo
}
Come faccio ad inserire ulteriore testo in quella funzione già scritta?
Questa è una piccolissima parte della creazione e gestione dei nodi.
