Galleria di interfacce utente scritte in MQL - pagina 70

Nuovo commento
 
Oggi pubblicherò una continuazione dell'argomento dell'indicazione a colori dei valori dei parametri - lampeggiamento degli elementi. Il compito si è rivelato un po' più complicato di quanto pensassi, quindi ho ritardato. Alla fine, la soluzione ha giustificato il tempo impiegato. Secondo me, in ogni caso.
 
Lo si può capire.
 
Jin Rong Xia #:
Lei può capirlo.
Sì, ti capisco. Il traduttore funziona bene.
 

Argomento 14.3: Indicazione di valori pericolosi mediante il lampeggiamento di parti di elementi (cornici, basi, testo, cursori e pannelli di scorrimento).

Il lampeggiamento degli elementi è un'ottima aggiunta all'indicazione a colori che segnala il passaggio dei parametri nella zona dei valori pericolosi. L'implementazione della nuova soluzione è simile a quella precedente, ma se l'indicazione a colori funziona secondo il principio che più il valore è vicino al valore critico, più il colore è brillante, il lampeggiamento aumenta solo la frequenza di cambiamento del colore iniziale con il colore impostato per il lampeggiamento. L'utente può regolare programmaticamente il ritardo del lampeggiamento, riducendolo gradualmente a 25 ms o aumentandolo a 2,5 secondi. In questo caso, entrambi i meccanismi possono funzionare contemporaneamente. Il colore passa dal verde chiaro al rosso brillante e al bordeaux e il lampeggiamento aumenta di velocità. Un meccanismo non interferisce con il secondo. A seguire, gli esempi pratici.

*Importante: il lampeggio si attiva indipendentemente dalle funzioni di indicazione del colore. I due meccanismi non sono tecnicamente correlati e possono funzionare in parallelo o separatamente.

Per implementare il lampeggiamento, sono state aggiunte nuove proprietà agli elementi interattivi:

  • pn_BLINK_frame -. Lampeggiamento della cornice Aggiunto a tutti i controlli che hanno una cornice. Sono esclusi i seguenti elementi: H_SLIDER, V_SLIDER, VALUE , R_BUTTON, CHECKBOX.
  • pn_ BLINK_text - Testo lampeggiante Aggiunto a tutti gli elementi che hanno un testo. Sono esclusi gli elementi: P_BAR, D_BAR, H_SLIDER, V_SLIDER.
  • pn_BLINK_base - Base del lampeggio Aggiunto a tutti gli elementi che hanno una base. Sono esclusi i seguenti elementi: CHECKBOX, R_BUTTON, D_LIST, C_LIST, VALUE.
  • pn_BLINK_bar -Barra lampeggiante. Aggiunto agli elementi con una barra: P_BAR , D_BAR,H_SLIDER, V_SLIDER.
  • pn_BLINK_handle - Lampeggiamento del cursore. Aggiunto ai cursori H_SLIDER, V_SLIDER.


Aggiunte nuove proprietà per controllare la velocità e l'arresto del lampeggiamento:

  • pn_BLINK_DELAY - Ritardo di lampeggiamento. Aggiunto a tutti gli elementi principali, senza eccezioni. * Importante : il ritardo è impostato per tutte le parti lampeggianti dell'elemento e non può differire da una parte all'altra. Tutte le parti dell'elemento con lampeggio abilitato via software (possono essere diverse) lampeggiano in modo sincrono. Tuttavia, la velocità di lampeggio tra gli elementi può essere diversa e ciò è a totale discrezione dell'utente.
  • pn_BLINK_STOP Ilcomando che interrompe completamente il lampeggio di tutti i componenti dell'elemento.
  • Allo stato attuale, è possibile abilitare il lampeggiamento della cornice della finestra delle impostazioni. Per farlo, è necessario chiamare la funzione window e passarle l'identificatore della proprietà pn_BLINK_frame. E il colore. Tutto è esattamente come per gli elementi.

Riassumiamo quanto detto sopra:

  • Il ritardo di lampeggiamento pn_BLINK_DELAY viene impostato programmaticamente e viene applicato a tutte le parti lampeggianti dell'elemento contemporaneamente. Esse lampeggiano in modo sincrono.
  • La proprietà pn_BLINK_DELAY ha un valore predefinito. A meno che l'utente non lo specifichi esplicitamente, il ritardo di lampeggiamento sarà 20, ovvero poco più di un secondo (20*25ms).
  • Un elemento può avere il lampeggio di più parti contemporaneamente o di una parte alla volta. La decisione spetta all'utente.
  • Nel processo di lampeggiamento è possibile modificare programmaticamente il colore e regolare la velocità. Le funzioni di lampeggiamento saranno discusse di seguito.
  • Per far lampeggiare un'altra parte dell'elemento è necessario chiamare la funzione e passare l'identificatore della parte dell'elemento e il colore. Ma se, ad esempio, un riquadro sta lampeggiando e l'utente vuole che il testo lampeggi al valore desiderato, e il riquadro smette di lampeggiare, è necessario disattivare completamente il lampeggiamento con il comando pn_BLINK_STOP, e poi attivare il lampeggiamento del testo con una chiamata al programma.
  • Su richiesta dell'utente, i componenti dell'elemento possono lampeggiare in colori diversi. Ad esempio, il testo può essere impostato per lampeggiare in verde, la cornice in blu e la base in rosso. Sono disponibili diverse varianti. Ma ricordiamo che la velocità di lampeggiamento di tutte le parti di un elemento è la stessa.
  • Se una finestra è ridotta a icona e la sua scheda si trova sulla barra delle applicazioni, e nella finestra sono presenti elementi lampeggianti, la scheda selezionerà automaticamente l'elemento che lampeggia più velocemente nella finestra chiusa (non c'è un vero e proprio ridisegno quando la finestra è chiusa) e si adatterà alla sua frequenza e al suo colore. In altre parole, le schede della barra delle applicazioni lampeggiano con il colore e la velocità dell'elemento lampeggiante più veloce della finestra. Ma se gli elementi cambiano la loro velocità di lampeggiamento durante la ricezione dei valori, la scheda si ricostruisce automaticamente trovando un altro elemento e cambiando la sua velocità di lampeggiamento e il suo colore.
  • In caso di disabilitazione completa del lampeggiamento degli elementi della finestra, la scheda smette di lampeggiare automaticamente.

Domani passeremo agli esempi pratici.

Oggi si tratta solo di una piccola dimostrazione per capire di cosa stiamo parlando.



Purtroppo, durante la registrazione si verificano dei ritardi. Il processore è carico. Ma la demo mostra che gli elementi lampeggiano in modo asincrono e a velocità diverse. Anche diverse parti degli elementi lampeggiano. Tutto questo è impostato in modo programmatico. La scheda sulla barra delle applicazioni individua automaticamente l'elemento che lampeggia più velocemente e diventa blu. Poi, quando l'elemento ha iniziato a lampeggiare meno spesso, ha trovato l'altro elemento che lampeggiava più velocemente ed è diventato rosso.

Domani analizzeremo questo aspetto in modo più dettagliato.

P.S. Discuteremo anche le opzioni di utilizzo di queste utilissime funzioni.

 


Dopo l'argomento di ieri...

Oggi riassumeremo concettualmente e concluderemo l'argomento del lampeggiamento degli elementi.

Ieri ho esaminato il lampeggiamento solo nel contesto della segnalazione di valori pericolosi, ma l'applicazione può essere molto più ampia. Ecco un esempio:

Immaginiamo un Expert Advisor multivaluta che analizza la situazione di diverse piazze. Supponiamo che selezioni i punti di entrata/uscita ottimali in base a una serie di criteri complessi. L'Expert Advisor lavora in modalità semi-automatica e il trader non può o non vuole programmare l'intera logica della strategia di trading. Il suo robot monitora i mercati, raccoglie dati e informa sui punti importanti. Il lavoro dell'esperto si limita all'analisi e alla visualizzazione dei risultati in tabelle e diagrammi. La decisione finale sulle transazioni è presa da una persona.

In questa variante, l'attività di trading consiste nell'osservare i flussi di dati in tempo reale e nel confezionare la serie di valori in corso in parametri personalizzati. Questi ultimi aiutano a scalare la consapevolezza della situazione.

Tuttavia, l'impegno dal vivo richiede decisioni tempestive. Il problema sorge quando i risultati dell'analisi vengono visualizzati in finestre diverse attraverso più viste grafiche. La quantità di informazioni che richiedono attenzione cresce e l'attenzione si divide. Di conseguenza, la prospettiva di mercato si offusca nella mente del trader e l'efficienza del suo lavoro diminuisce. La stanchezza si fa sentire.

In questo caso gli elementi lampeggianti sono un valido aiuto:

  • Segnalano l'urgenza di prendere decisioni o intraprendere azioni.
  • Segnala la velocità dei cambiamenti in arrivo.
  • Segnala la rilevanza degli eventi osservati.
  • Informa sul significato dei risultati ottenuti: cifre, differenze, intervalli, somme, limiti, ecc.

Riassumendo:
  • Il lampeggio può ricordare, avvertire, informare, segnalare o indicare.
  • Il lampeggiamento favorisce l'attenzione e aumenta la concentrazione del professionista.
  • La frequenza e il colore determinano l'urgenza delle decisioni o delle azioni.
  • In combinazione con il cambio di colore, il lampeggiamento aumenta l'interattività dell'interfaccia grafica e l'efficienza del trader.

Passiamo alla descrizione pratica delle nuove funzionalità:

  • 1. Prescriviamo l'ordine delle azioni preparatorie.
  • 2. Abilitiamo il lampeggiamento del riquadro del pulsante quando lo si preme e disabilitiamolo quando lo si disattiva.
  • 3. Attiviamo il lampeggiamento del testo del pulsante.
  • 4. Attiviamo il lampeggiamento della base del pulsante.
  • 5. Colleghiamo diversi altri elementi al lampeggiamento del pulsante: un campo con pulsanti, un cursore, una casella di controllo e altri.
  • 6. Attiviamo il lampeggiamento della cornice della finestra.
  • 7. Colleghiamo la velocità di lampeggiamento degli elementi con il valore del cursore e del campo con pulsanti.

//----------------------------------------------------------------------------------------------------------

1. Ordine delle azioni preparatorie:

  • Per prima cosa, scriviamo i wrapper delle funzioni Blink_start() e Blink_stop(), che devono attivare e disattivare il lampeggiamento degli elementi quando vengono chiamate.
  • La funzione Blink_start() sarà responsabile dell'accensione. Sarà chiamata sull'evento di pressione. La funzione Blink_stop() è responsabile della disattivazione del lampeggio. Verrà richiamata quando il pulsante "Start" verrà premuto .
  • Individuiamo il pulsante nel file API e scriviamo la chiamata della funzione Blink_start() alla pressione del pulsante e la chiamata della funzione Blink_stop() alla sua pressione . 
//-----------------------------------------------------
//This function will start the blinking of the elements.
//-----------------------------------------------------
void Blink_start()
{

}
//-----------------------------------------------------
//This function will stop the blinking of the elements.
//-----------------------------------------------------
void Blink_stop()
{

}


Ora troviamo il caso del pulsante "Start" nel file API e scriviamo le chiamate delle funzioni Blink_start() e Blink_stop() sull'evento di pressione e pressione del pulsante:

case Settings_example_1___Start:
  
               //------------------------------------------------------------------------------------------------------
               //What to do when the button is pressed or released?
               //------------------------------------------------------------------------------------------------------
               switch((int)action)
               {
                case pressed:    Blink_start();  break;
  
                case released:   Blink_stop();   break;
               }
               //------------------------------------------------------------------------------------------------------
               //Your comment:
               //------------------------------------------------------------------------------------------------------
               break;


Passiamo a riempire le funzioni con il contenuto:

1. Abbiamo bisogno che il frame del pulsante "Start" lampeggi. Scriviamo una chiamata per il lampeggiamento della cornice, come mostrato nel codice sottostante. L'identificatore della proprietà di lampeggiamento della cornice del pulsante è p1_BLINK_frame. Specificare il colore del lampeggiamento e l'oggetto del lampeggiamento.

void Blink_start()
{
 //Setting the color and the part of the element that is suppoused to blink.
 w6_i_p1_BUTTON_Start((int)clrLimeGreen,p1_BLINK_frame);
}


2. Ora implementiamo la disabilitazione del lampeggiamento quando il pulsante viene rilasciato. L'identificatore p1_BLINK_STOP è responsabile della disattivazione del lampeggio . Non è necessario mettere nulla tra parentesi, tranne che per questo identificatore.

void Blink_stop()
{
 //Stopping the blinking of all of the parts of the element all together:
 w6_i_p1_BUTTON_Start(p1_BLINK_STOP);
}


Verifichiamo il risultato:



3. Attiviamo il lampeggiamento del testo del pulsante anziché della cornice. L'identificatore della proprietà pn_BLINK_text è responsabile del lampeggiamento del testo:

void Blink_start()
{
 //Setting the color and the part of the element that is suppoused to blink.
 w6_i_p1_BUTTON_Start((int)clrRed,p1_BLINK_text);
}

Risultato: il testo del pulsante lampeggia in blu e smette di lampeggiare quando il pulsante viene premuto.



4. Attiviamo il lampeggiamento della base del pulsante. L'identificatore della proprietà pn_BLINK_base è responsabile della base:

void Blink_start()
{
 //Setting the color and the part of the element that is suppoused to blink.
 w6_i_p1_BUTTON_Start((int)clrRed,p1_BLINK_base);
}

Risultato: la base del pulsante lampeggia in rosso e smette di lampeggiare quando viene premuto.



Ora combiniamo il lampeggiamento della cornice del pulsante e del suo testo:

void Blink_start()
{
 //Setting the blinking of the frame and the text of the button
 w_6_Settings_example_1((int)clrRed,p8_BLINK_frame);
 w_6_Settings_example_1((int)clrRed,p8_BLINK_text);
}

Risultato: lacornice del pulsante e il testo del pulsante lampeggiano in modo sincrono con colori diversi, come previsto.


5. Colleghiamo altri elementi di questa finestra al lampeggiamento: 

void Blink_start()
{
 //Setting the color and the part of the element that is suppoused to blink.
 //-------------------------------------------------------------
 w6_i_p1_BUTTON_Start((int)clrLimeGreen,p1_BLINK_frame);
 w6_i_p1_BUTTON_Start((int)clrRed,p1_BLINK_text);
 //-------------------------------------------------------------
 w6_d_p5_S_EDIT_Spin_the_value((int)C'255,50,0',p5_BLINK_frame);
 w6_d_p5_S_EDIT_Spin_the_value((int)C'255,50,0',p5_BLINK_text);
 //-------------------------------------------------------------
 w6_i_p3_H_SLIDER_Roll_the_value((int)C'255,50,0',p3_BLINK_handle);
 w6_i_p3_H_SLIDER_Roll_the_value((int)C'255,50,0',p3_BLINK_bar);
 //-------------------------------------------------------------
 w6_i_p7_CHECKBOX_Set_an_option((int)C'255,50,0',p7_BLINK_text);
 //-------------------------------------------------------------
 w6_s_p6_D_LIST_D_LIST_1((int)C'255,50,0',p6_BLINK_frame);
 //-------------------------------------------------------------
}

Scriviamo anche la disabilitazione del lampeggiamento all'interno della funzione Blink_stop( ) : 

void Blink_stop()
{
 //Stopping the blinking
 //-------------------------------------------------------------
 w6_i_p1_BUTTON_Start(p1_BLINK_STOP);
 //-------------------------------------------------------------
 w6_d_p5_S_EDIT_Spin_the_value(p5_BLINK_STOP);
 //-------------------------------------------------------------
 w6_i_p3_H_SLIDER_Roll_the_value(p3_BLINK_STOP);
 //-------------------------------------------------------------
 w6_i_p7_CHECKBOX_Set_an_option(p7_BLINK_STOP);
 //-------------------------------------------------------------
 w6_s_p6_D_LIST_D_LIST_1(p6_BLINK_STOP);
 //-------------------------------------------------------------
}

Risultato: i nuovi elementi sono inclusi in Blink_start() e Blink_stop() e lampeggiano come previsto.


6. Facciamo in modo che la cornice della finestra lampeggi quando si fa clic sul pulsante. (Disabilitiamo temporaneamente il lampeggiamento degli elementi in ritardo).

void Blink_start()
{
//Setting the blinking of the frame of the window:
 w_6_Settings_example_1((int)clrRed,p8_BLINK_frame);
}

void Blink_stop()
{
//Stopping the blinking of the frame of the window:
 w_6_Settings_example_1(p8_BLINK_STOP);
}


Risultato: la cornice della finestra lampeggia come dovrebbe.


*Importante: tutti gli elementi considerati e la cornice della finestra lampeggiano alla velocità predefinita.

In seguito, regoleremo la velocità di lampeggiamento degli elementi con la maniglia di scorrimento e del campo con i pulsanti.


7. Leghiamo la velocità di lampeggiamento al valore del campo con pulsanti e cursore. Tutti gli elementi e la cornice della finestra lampeggeranno contemporaneamente e la velocità di lampeggiamento sarà impostata manualmente da questi elementi.

Ricordiamo che la velocità di lampeggiamento dipende dal ritardo pn_BLINK_DELAY.

  • Il ritardo minimo possibile è 1, mentre quello massimo è 99.
  • Per calcolare il ritardo di lampeggio, è necessario moltiplicare il suo valore per 25 (ms).
  • Per impostazione predefinita, il ritardo è pari a 20, ovvero 500 millisecondi (20*25ms).

Per risolvere il problema, procediamo come segue:

  • 1. Riportiamo il lampeggio di tutti gli elementi alla pressione/rilascio del pulsante e aggiungiamo ad essi il lampeggio della finestra di chiamata/arresto.
  • 2. Scriviamo una nuova funzione Blink_delay() in cui inseriremo le chiamate che impostano una pausa nel lampeggio. La funzione accetta il valore del ritardo.
  • 3. Scriviamo una chiamata alla funzione Blink_delay() dai casi degli elementi di scorrimento e dei campi di input nel file API, passando il valore corrente.

A bbiamo aggiunto il lampeggiamento della finestra all'interno della funzione Blink_start(): . 

void Blink_start()
{
 //Setting the color and the part of the element that is suppoused to blink.
 //-------------------------------------------------------------
 w_6_Settings_example_1((int)clrRed,p8_BLINK_frame);
 //-------------------------------------------------------------
 w6_i_p1_BUTTON_Start((int)clrLimeGreen,p1_BLINK_frame);
 w6_i_p1_BUTTON_Start((int)clrRed,p1_BLINK_text);
 //-------------------------------------------------------------
 w6_d_p5_S_EDIT_Spin_the_value((int)C'255,50,0',p5_BLINK_frame);
 w6_d_p5_S_EDIT_Spin_the_value((int)C'255,50,0',p5_BLINK_text);
 //-------------------------------------------------------------
 w6_i_p3_H_SLIDER_Roll_the_value((int)C'255,50,0',p3_BLINK_handle);
 w6_i_p3_H_SLIDER_Roll_the_value((int)C'255,50,0',p3_BLINK_bar);
 //-------------------------------------------------------------
 w6_i_p7_CHECKBOX_Set_an_option((int)C'255,50,0',p7_BLINK_text);
 //-------------------------------------------------------------
 w6_s_p6_D_LIST_D_LIST_1((int)C'255,50,0',p6_BLINK_frame);
 //-------------------------------------------------------------
}

Abbiamo aggiunto la disabilitazione del lampeggiamento del riquadro della finestra nella funzione Blink_stop(): 

void Blink_stop()
{
 //Stopping the blinking
 //-------------------------------------------------------------
 w_6_Settings_example_1(p8_BLINK_STOP);
 //-------------------------------------------------------------
 w6_i_p1_BUTTON_Start(p1_BLINK_STOP);
 //-------------------------------------------------------------
 w6_d_p5_S_EDIT_Spin_the_value(p5_BLINK_STOP);
 //-------------------------------------------------------------
 w6_i_p3_H_SLIDER_Roll_the_value(p3_BLINK_STOP);
 //-------------------------------------------------------------
 w6_i_p7_CHECKBOX_Set_an_option(p7_BLINK_STOP);
 //-------------------------------------------------------------
 w6_s_p6_D_LIST_D_LIST_1(p6_BLINK_STOP);
 //-------------------------------------------------------------
}

Scrivere la funzione Blink_delay():

Chiamare la funzione Blink_delay() sull'evento del cursore e degli elementi del campo di input e passarle il valore corrente degli elementi:

void Blink_delay(uint delay)
{
 if(delay > 0 && delay < 100)
   {
    //-------------------------------------------------------------
    w_6_Settings_example_1(delay,p8_BLINK_DELAY);
    //-------------------------------------------------------------
    w6_i_p1_BUTTON_Start(delay,p1_BLINK_DELAY);
    //-------------------------------------------------------------
    w6_d_p5_S_EDIT_Spin_the_value(delay,p5_BLINK_DELAY);
    //-------------------------------------------------------------
    w6_i_p3_H_SLIDER_Roll_the_value(delay,p3_BLINK_DELAY);
    //-------------------------------------------------------------
   }
else Print("Wrong value!");
}

*Nota importante: si è scoperto che è impossibile modificare la velocità di lampeggiamento degli elementi checkbox e dropdown. Questa velocità è sempre pari a 20 (mezzo secondo). Questo è stato fatto intenzionalmente, ma probabilmente lo cambierò in futuro. Gli altri elementi possono cambiare la velocità di lampeggiamento.

Scriviamo una chiamata alla funzione Blink_delay() dall'evento dell'elemento "Spin_the_value" (il campo con i pulsanti). Il campo è collegato al cursore, quindi non è necessario inserire la chiamata nel caso del cursore. Il collegamento funzionerà e il cursore, senza una chiamata diretta, cambierà la velocità di lampeggiamento attraverso il campo con i pulsanti:

case Settings_example_1___Spin_the_value:
  
               //------------------------------------------------------------------------------------------------------
               //What to do when the value is set?
               //------------------------------------------------------------------------------------------------------
               //Min value:  NOT SET  |   Max value:  NOT SET  |   V_step:  1.7  |   Default value:  468.99  |  Digits: 3
               //------------------------------------------------------------------------------------------------------
               w6_i_p3_H_SLIDER_Roll_the_value((int)value);
              
               //Сalling the blinking delay function
               Blink_delay((int)value);
               //------------------------------------------------------------------------------------------------------
               //Your comment:
               //------------------------------------------------------------------------------------------------------
               break;


Risultato: il campo con i pulsanti e il cursore modificano la velocità di lampeggiamento degli elementi della finestra.



Risultati:

  • Implementando il lampeggiamento degli elementi, l'interfaccia è molto più interattiva e informativa di prima.
  • I metodi per attivare, controllare e disattivare il lampeggiamento degli elementi sono molto semplici e sono descritti in dettaglio in due post di questa pagina.
  • I metodi sono elencati e dimostrati con esempi di codice e video.
  • Probabilmente alcune sfumature potranno essere migliorate o aggiunte in futuro, ma in linea di massima le funzioni di base del lampeggiamento sono già state aggiunte e non richiedono grandi modifiche.
  • È possibile cambiare il colore del lampeggiamento modificando il valore del parametro dell'elemento.

Considero questo argomento esaurito.


Il prossimo punto dell'elenco è l'annullamento dei valori inseriti premendo il pulsante "Annulla".

 
La prossima versione sarà rilasciata lunedì o martedì della prossima settimana. L'aggiornamento includerà le funzioni illustrate sopra, nonché la cancellazione/conferma dell'inserimento dei parametri nelle finestre di impostazione. Inoltre, i cataloghi saranno tradotti in inglese e il codice sarà migliorato e corretto in base all'elenco dei problemi identificati.
 
Реter Konow #:
La prossima versione sarà rilasciata lunedì o martedì della prossima settimana. L'aggiornamento includerà le funzioni illustrate sopra, nonché la cancellazione/conferma dell'inserimento dei parametri nelle finestre di impostazione. Inoltre, i cataloghi saranno tradotti in inglese e il codice sarà sottoposto a modifiche e correzioni da un elenco compilato di problemi identificati.
Speriamo nel tempo.
 
Il lavoro è trascurato, o semplicemente avete una "stagione di velluto", una vacanza? Beh, questo è sacro.
 
Edgar Akhmadeev #:
Il lavoro è trascurato, o semplicemente avete una "stagione di velluto", una vacanza? Bene, questo è sacro.
Il lavoro non è finito, ma le priorità sono state ristrutturate. Forse continuerò, se ci sarà una richiesta pubblica. Ho comunque bisogno di tabelle dinamiche e generate. E anche di grafici. Li farò di sicuro. Il resto - come si scopre.
 
Реter Konow #:
Forse continuerò se c'è una richiesta da parte del pubblico.

La domanda c'è. Il fatto che la maggior parte delle persone taccia sull'argomento è normale. La gente sta in agguato e aspetta. Finora non è stato portato a termine nessun progetto importante. È sempre difficile farcela da soli e senza finanziamenti. Finora conosco solo un progetto portato a termine con successo da una sola persona: "VLADIK BRUTAL" su Steam.

1...6364656667686970717273
Nuovo commento