RiskGuard Strategy Specification Config. 1
Versione B1.01 del 15/07/2026 BETA

Questa pagina contiene l'intera specifica tecnica necessaria per creare indicatori compatibili con RiskGuard Config 1.
L’unico metodo supportato per l’invio dei segnali è tramite le Global Variables ufficiali di RiskGuard Config 1.

Scopo della pagina  
Questa pagina definisce le regole obbligatorie per creare un indicatore MQL5 compatibile con la modalità Strategy di RiskGuard Management.

Il documento è destinato a:

	•	Sviluppatori MQL5
	•	Sistemi di Intelligenza Artificiale
	•	Generatori automatici di codice
	•	Creatori di strategie compatibili con RiskGuard

Quando una regola è indicata come obbligatoria deve essere rispettata senza eccezioni.

L'obiettivo dell'indicatore è esclusivamente generare segnali operativi.

Tutta la gestione del trading viene eseguita da RiskGuard.

Cosa deve fare l'indicatore  
L’indicatore deve:

	•	Analizzare il mercato
	•	Generare segnali operativi
	•	Inviare comandi BUY, SELL, BREAK EVEN o CLOSE
	•	Leggere opzionalmente le linee operative create da RiskGuard
	•	Utilizzare esclusivamente il protocollo ufficiale Config 1

Cosa non deve fare l'indicatore  
L'indicatore non deve:

	•	Aprire operazioni
	•	Chiudere operazioni
	•	Modificare operazioni
	•	Calcolare il lotto
	•	Gestire il rischio
	•	Gestire Break Even
	•	Gestire Take Profit parziali
	•	Gestire Trailing Stop
	•	Gestire limiti di perdita giornalieri
	•	Gestire Quantum

Tutte queste funzioni sono gestite esclusivamente da RiskGuard.

Nome dell'indicatore  
Il nome dell'indicatore deve iniziare con:

RiskGuard_

Esempi validi:

RiskGuard_ORB
RiskGuard_MACD
RiskGuard_Stochastic
RiskGuard_Breakout

Esempi non validi:

ORB
MACD
RG_ORB
AutoStrategy

RiskGuard può rifiutare automaticamente indicatori che non iniziano con il prefisso RiskGuard_.

Indipendenza dal timeframe del grafico  
RiskGuard è progettato per operare con una sola finestra grafico per ogni simbolo e salvato come modello default.

L'utente può cambiare liberamente il timeframe del grafico in qualsiasi momento.

L'indicatore deve garantire che il cambio timeframe del grafico non alteri il comportamento della strategia.

Il cambio timeframe non deve:

	•	Modificare la logica della strategia
	•	Modificare i segnali generati
	•	Generare nuovi segnali
	•	Generare segnali duplicati
	•	Generare segnali retroattivi

Se la strategia utilizza uno o più timeframe specifici, questi devono essere definiti internamente dall'indicatore.

La logica della strategia non deve dipendere dal timeframe attualmente visualizzato sul grafico.

Divieto di segnali retroattivi  
L'indicatore deve generare segnali esclusivamente in tempo reale.

Se una condizione operativa si è verificata prima del caricamento dell'indicatore, il segnale deve essere ignorato.

Esempio:
 
	•	BUY alle 11:00
	•	indicatore caricato alle 15:00
	•	non deve inviare BUY retroattivo

Divieto di segnali duplicati  
Lo stesso segnale non deve essere inviato più volte.

Lo sviluppatore dell'indicatore è completamente responsabile della prevenzione dei segnali duplicati.

L'indicatore deve garantire che:

	•	Un refresh del grafico non generi duplicati
	•	Un cambio timeframe non generi duplicati
	•	Una reinizializzazione dell'indicatore non generi duplicati
	•	Lo stesso evento operativo non venga inviato più volte

Divieto di funzioni operative  
Un indicatore compatibile con RiskGuard non deve eseguire direttamente operazioni di trading.

Non devono essere utilizzate funzioni come:

OrderSend()
Buy()
Sell()
PositionOpen()
PositionClose()
PositionModify()
 
RiskGuard è l'unico componente autorizzato ad eseguire operazioni.

Gestione della rimozione dell’indicatore  
Quando un indicatore compatibile con RiskGuard viene rimosso dal grafico, è consigliato ripulire correttamente tutte le risorse create dall’indicatore.

Ad esempio:

	•	Global Variables interne all’indicatore
	•	Oggetti grafici
	•	Box
	•	Linee
	•	Label
	•	Variabili di stato persistenti

Questo riduce il rischio di:

	•	segnali duplicati
	•	segnali residui
	•	oggetti lasciati sul grafico
	•	comportamenti inattesi al riavvio dell’indicatore

È consigliato implementare questa logica all’interno di:

OnDeinit()

Particolare attenzione deve essere posta al caso:

REASON_CHARTCHANGE

MetaTrader reinizializza l’indicatore anche durante il cambio timeframe.

In molti casi, cancellare tutte le variabili durante REASON_CHARTCHANGE può causare segnali duplicati dopo il reload.

Per questo motivo, la logica di cleanup deve essere progettata con attenzione in base al comportamento della strategia.

Esempio:

void OnDeinit(const int reason)
  {
   if(reason == REASON_CHARTCHANGE)
      return;

      GlobalVariableDel(LastSignalGVName());       ObjectDelete(0, "MyStrategyBox");       ObjectDelete(0, "MyStrategyLine");

  }

La logica di cleanup dipende interamente dal comportamento della strategia.

Non tutti gli indicatori richiedono la stessa gestione in OnDeinit().

Lo sviluppatore è responsabile di implementare una logica coerente con il comportamento della propria strategia.

Funzione ufficiale SendRiskGuardConfig1Signal()  
ATTENZIONE
 
La funzione SendRiskGuardConfig1Signal() riportata in questa pagina è parte integrante del protocollo ufficiale RiskGuard.
 
La funzione deve essere copiata integralmente senza alcuna modifica.
 
Non è consentito:
 
- modificare il codice
- ottimizzare il codice
- rifattorizzare il codice
- riscrivere il codice
- sostituire istruzioni equivalenti
- aggiungere istruzioni
- rimuovere istruzioni
 
La funzione deve essere riportata identica carattere per carattere.
 
Qualsiasi modifica rende l'indicatore non conforme alle specifiche RiskGuard.

//+------------------------------------------------------------------+
//| Official RiskGuard signal function  Config. 1                    |
//|                                                                  |
//|                                                                  |
//| DO NOT MODIFY THIS FUNCTION.                                     |
//| This function must remain identical in all RiskGuard-compatible  |
//| indicators.                                                      |
//+------------------------------------------------------------------+
void SendRiskGuardConfig1Signal(string action)
{
   GlobalVariableDel("RG_Strategy_Config1_Buy_" + _Symbol);
   GlobalVariableDel("RG_Strategy_Config1_Sell_" + _Symbol);
   GlobalVariableDel("RG_Strategy_Config1_Close_" + _Symbol);
   GlobalVariableDel("RG_Strategy_Config1_Be_" + _Symbol);
 
   if(action == "BUY")
      GlobalVariableSet("RG_Strategy_Config1_Buy_" + _Symbol, 1);
 
   else if(action == "SELL")
      GlobalVariableSet("RG_Strategy_Config1_Sell_" + _Symbol, 1);
 
   else if(action == "CLOSE")
      GlobalVariableSet("RG_Strategy_Config1_Close_" + _Symbol, 1);
 
   else if(action == "BE")
      GlobalVariableSet("RG_Strategy_Config1_Be_" + _Symbol, 1);
 
   else
      Print("[RG CONFIG 1] Invalid action: ", action);
}
//+------------------------------------------------------------------+

Invio di un segnale BUY  
Esempio:

 
SendRiskGuardConfig1Signal("BUY");

Invio di un segnale SELL  
Esempio:

 
SendRiskGuardConfig1Signal("SELL");

Invio di un segnale BREAK EVEN  
Esempio:

 
SendRiskGuardConfig1Signal("BE");

Invio di un segnale CLOSE  
Esempio:

 
SendRiskGuardConfig1Signal("CLOSE");

Lettura linee operative  

 
	•	double LineaStopBuySell = ObjectGetDouble(ChartID(), "LineaStopBuySell", OBJPROP_PRICE, 0);
	•	double LineaTakeBuySell = ObjectGetDouble(ChartID(), "LineaTakeBuySell", OBJPROP_PRICE, 0);
	•	double LineaMediaBuySell = ObjectGetDouble(ChartID(), "LineaMediaBuySell", OBJPROP_PRICE, 0);
	•	double LineaStopPrevista = ObjectGetDouble(ChartID(), "LineaStopPrevista", OBJPROP_PRICE, 0);
	•	double LineaMediaPrevista = ObjectGetDouble(ChartID(), "LineaMediaPrevista", OBJPROP_PRICE, 0);

Cosa fa RiskGuard dopo aver ricevuto un segnale  
Dopo aver ricevuto un segnale, RiskGuard può:

	•	Aprire un ordine market Buy
	•	Aprire un ordine market Sell
	•	Portare a break even tutti gli ordini della config 1
	•	Chiudere tutti gli ordini della config 1

L'indicatore non è responsabile di nessuna di queste operazioni.

Magic Number utilizzati da RiskGuard  
Quando RiskGuard apre operazioni tramite la modalità Strategy in "CONFIG. 1", utilizza sempre il seguente Magic Number fisso:

30033000

aperti in seguito a un segnale generato da un indicatore compatibile con RiskGuard.

Questo permette allo sviluppatore dell’indicatore di identificare facilmente ordini e posizioni generate dalla modalità Strategy.

Ad esempio, un indicatore può verificare se esistono posizioni o ordini aperti da RiskGuard Strategy filtrando il Magic Number:

30033000

Tutti gli altri trade aperti direttamente da RiskGuard (non tramite Strategy Mode) utilizzano invece Magic Number appartenenti al range riservato RiskGuard.

Per questo motivo, se uno sviluppatore desidera monitorare esclusivamente l’attività generata dalla Strategy Mode "CONFIG.1", deve filtrare esclusivamente il Magic Number:

30033000

Responsabilità e supporto  
L'indicatore e RiskGuard sono componenti separati.

RiskGuard non conosce la logica utilizzata dall'indicatore per generare il segnale.

Dopo aver ricevuto un segnale valido, RiskGuard si comporta esattamente come se l'utente avesse premuto uno dei pulsanti  "BUY" , "SELL" , "BE" e "CLOSE" del pannello in "CONFIG.1" .

RiskGuard non riceve informazioni sulla logica della strategia.

Supporto tecnico  
RiskGuard fornisce supporto esclusivamente per:

	•	Installazione di RiskGuard
	•	Configurazione di RiskGuard
	•	Funzionamento delle funzioni di RiskGuard
	•	Problemi relativi a RiskGuard

RiskGuard non fornisce supporto gratuito per:

	•	Strategie sviluppate da terze parti
	•	Indicatori sviluppati da terze parti
	•	Codice creato tramite Intelligenza Artificiale
	•	Modifiche personalizzate richieste dagli utenti

Per qualsiasi problema relativo alla logica della strategia o al funzionamento dell'indicatore, l'utente deve contattare direttamente lo sviluppatore dell'indicatore.

Validazione del segnale  
La ricezione di un segnale non garantisce l'apertura di un'operazione.

Prima dell'apertura, RiskGuard applica tutti i controlli normalmente previsti dal sistema.

Ad esempio:

	•	segnali multipli invalidi
	•	BUY/SELL simultanei invalidi
	•	direzioni opposte invalidate
	•	impostazioni del''utente di blocchi in config 1
	•	Altri controlli interni di sicurezza

Se uno dei controlli impedisce l'apertura dell'operazione, il segnale viene ignorato ed eliminato e nessun trade viene aperto.

Compatibilità con Strategy Tester  
RiskGuard può essere utilizzato all'interno dello Strategy Tester di MetaTrader.

Quando RiskGuard carica un indicatore tramite il parametro:

StrategyIndicator

MetaTrader consente di modificare esclusivamente gli input di RiskGuard.

Gli input dell'indicatore strategico non sono accessibili direttamente dalla finestra dello Strategy Tester di RiskGuard.

Per consentire all'utente finale di modificare gli input della strategia durante i test, lo sviluppatore deve fornire un file .mq5
contenente almeno la definizione degli input della strategia.

Esempio:

input int SignalHour = 9;

input int SignalMinute = 0;

input int StopDistancePoints = 1000;

Questo permette all'utente di compilare l'indicatore con i parametri desiderati e utilizzarlo nello Strategy Tester insieme a RiskGuard.

Consigli per lo sviluppo e il backtest
 
Per migliorare le prestazioni durante il backtest, è consigliabile separare completamente la logica della strategia dalla sua rappresentazione grafica.

Gli indicatori, le linee, le medie mobili, le bande, i livelli e tutti gli altri elementi grafici utilizzati dalla strategia dovrebbero essere visualizzati:

	•	durante il normale utilizzo sul grafico;
	•	durante un backtest eseguito in modalità visuale.

Quando invece il backtest viene eseguito senza modalità visuale, è consigliabile non creare, non aggiornare e non disegnare alcun elemento grafico.

Questa soluzione permette di:

	•	velocizzare sensibilmente il backtest;
	•	ridurre il carico sulla piattaforma;
	•	evitare elaborazioni grafiche inutili;
	•	mantenere comunque tutti gli elementi visibili durante lo sviluppo, il controllo della strategia e l’utilizzo reale.

La logica che calcola i segnali deve continuare a funzionare normalmente anche quando la parte grafica è disattivata. Gli elementi visivi devono quindi essere utilizzati esclusivamente come supporto grafico e non devono essere necessari per generare i segnali della strategia.

In MQL5 è possibile verificare la modalità di esecuzione utilizzando le proprietà del programma, ad esempio:

 
bool showGraphics = true;
 
if(MQLInfoInteger(MQL_TESTER) &&
!MQLInfoInteger(MQL_VISUAL_MODE))
{
showGraphics = false;
}
 
La variabile showGraphics può quindi essere controllata prima di creare indicatori grafici, buffer visibili, oggetti, linee, etichette o altri elementi destinati esclusivamente alla visualizzazione.

Esempio:

 
if(showGraphics)
{
// Creazione o aggiornamento degli elementi grafici
}
 
È inoltre consigliabile:

	•	creare gli handle degli indicatori necessari ai calcoli anche nel backtest non visuale;
	•	evitare invece di aggiungerli graficamente al chart quando la modalità visuale non è attiva;
	•	non utilizzare oggetti grafici per memorizzare informazioni indispensabili alla strategia;
	•	mantenere separati il blocco di calcolo, il blocco di generazione dei segnali e il blocco grafico;
	•	evitare aggiornamenti grafici a ogni tick quando non sono realmente necessari.

Durante la creazione della strategia è consigliabile effettuare inizialmente alcuni test in modalità visuale, verificando che segnali, ingressi, Stop Loss e Take Profit siano coerenti con gli elementi mostrati sul grafico. Una volta verificato il corretto funzionamento, i test più lunghi possono essere eseguiti senza modalità visuale per ottenere una maggiore velocità.

Protezione della logica della strategia  
Lo sviluppatore può scegliere liberamente come distribuire la propria strategia.

Sono supportati entrambi gli approcci.

Strategia completamente aperta:

Indicatore.mq5

Strategia con logica protetta:

Indicatore.mq5

LibreriaProtetta.ex5

Il file .mq5 può contenere:

	•	Gli input della strategia
	•	La funzione SendRiskGuardConfig1Signal()
	•	Il collegamento alla libreria

La logica proprietaria può essere mantenuta all'interno di una o più librerie compilate.

In questo modo l'utente finale può modificare gli input della strategia durante i test senza avere accesso al codice proprietario.

Utilizzo su conto Demo o Reale  
Per l'utilizzo normale su conto Demo o Reale non è necessario distribuire il file .mq5.

L'utente può utilizzare normalmente il solo file:

Indicatore.ex5

e modificare gli input direttamente dalle proprietà dell'indicatore sul grafico.

Checklist finale  
Prima di considerare compatibile un indicatore verificare che:

✓ Il nome inizi con RiskGuard_

✓ Non utilizzi funzioni operative

✓ Non generi segnali retroattivi

✓ Non generi segnali duplicati

✓ Il comportamento non cambi al cambio timeframe del grafico

✓ Utilizzi le variabili globali del protocollo RiskGuard

✓ La gestione del rischio sia lasciata interamente a RiskGuard

Indicatori di esempio  
Questa pagina include un indicatore di esempio completo e funzionante.

L'indicatore rispetta integralmente le specifiche ufficiali di RiskGuard Strategy e può essere usato come riferimento per sviluppare strategie personalizzate.

L'indicatore ha lo scopo di mostrare:

	•	come strutturare un indicatore compatibile con RiskGuard
	•	come prevenire segnali duplicati
	•	come evitare segnali retroattivi
	•	come inviare correttamente segnali a mercato

Esempio 1 — RiskGuard_Config1_Demo.mq5  
Indicatore di esempio estremamente semplice.

Questo indicatore genera un segnale automatico a un orario specifico definito dall’utente.

L’obiettivo è mostrare il funzionamento minimo richiesto per un indicatore compatibile con RiskGuard.

Funzioni principali:

	•	Generazione di uno o più segnali a orari precisi
	•	Invio dei comandi BUY, SELL, BE e CLOSE
	•	Utilizzo dell’orario broker/server
	•	Protezione dai segnali duplicati
	•	Protezione dai segnali retroattivi
	•	Protezione dal cambio timeframe
	•	Compatibilità con il normale utilizzo e con lo Strategy Tester

Questo esempio è consigliato come punto di partenza per comprendere la logica base di integrazione con RiskGuard.

//+------------------------------------------------------------------+
//| RiskGuard_Config1_Demo.mq5                                       |
//+------------------------------------------------------------------+
#property indicator_chart_window
#property indicator_plots 0
 
//+------------------------------------------------------------------+
//| Demo indicator for RiskGuard Strategy - Config. 1                |
//|                                                                  |
//| This indicator is only an educational example.                   |
//| It does not open, close or modify trades directly.               |
//|                                                                  |
//| All trading operations are handled exclusively by RiskGuard.     |
//|                                                                  |
//| The purpose of this demo is to show how an external indicator    |
//| can send BUY, SELL, BE and CLOSE commands to RiskGuard Config. 1 |
//| using the official RiskGuard protocol.                           |
//+------------------------------------------------------------------+
 
enum RG_CONFIG1_ACTION
{
   ACTION_NONE  = 0,
   ACTION_BUY   = 1,
   ACTION_SELL  = 2,
   ACTION_BE    = 3,
   ACTION_CLOSE = 4
};
 
//--- FIRST DEMO SIGNAL
input string First_Signal_Time = "08:00:00";// Format HH:MM:SS using broker/server time.
input RG_CONFIG1_ACTION First_Signal_Action = ACTION_BUY;// Action sent at First_Signal_Time.
 
//--- NEXT DEMO SIGNALS
input int Signal_02_Seconds_After_First = 60;// 60 = signal 2 starts 1 minute after the first signal.
input RG_CONFIG1_ACTION Signal_02_Action = ACTION_BUY;// Action for signal 2.
 
input int Signal_03_Seconds_After_First = 120;// 120 = signal 3 starts 2 minutes after the first signal.
input RG_CONFIG1_ACTION Signal_03_Action = ACTION_BUY;// Action for signal 3.
 
input int Signal_04_Seconds_After_First = 180;// 180 = signal 4 starts 3 minutes after the first signal.
input RG_CONFIG1_ACTION Signal_04_Action = ACTION_BUY;// Action for signal 4.
 
input int Signal_05_Seconds_After_First = 240;// 240 = signal 5 starts 4 minutes after the first signal.
input RG_CONFIG1_ACTION Signal_05_Action = ACTION_NONE;// Action for signal 5.
 
input int Signal_06_Seconds_After_First = 300;// 300 = signal 6 starts 5 minutes after the first signal.
input RG_CONFIG1_ACTION Signal_06_Action = ACTION_NONE;// Action for signal 6.
 
input int Signal_07_Seconds_After_First = 360;// 360 = signal 7 starts 6 minutes after the first signal.
input RG_CONFIG1_ACTION Signal_07_Action = ACTION_NONE;// Action for signal 7.
 
input int Signal_08_Seconds_After_First = 420;// 420 = signal 8 starts 7 minutes after the first signal.
input RG_CONFIG1_ACTION Signal_08_Action = ACTION_NONE;// Action for signal 8.
 
input int Signal_09_Seconds_After_First = 480;// 480 = signal 9 starts 8 minutes after the first signal.
input RG_CONFIG1_ACTION Signal_09_Action = ACTION_NONE;// Action for signal 9.
 
input int Signal_10_Seconds_After_First = 540;// 540 = signal 10 starts 9 minutes after the first signal.
input RG_CONFIG1_ACTION Signal_10_Action = ACTION_CLOSE;// Action for signal 10.
 
datetime indicatorStartTime;
 
//+------------------------------------------------------------------+
int OnInit()
{
   indicatorStartTime = TimeCurrent();
 
   Print("[RG DEMO CONFIG 1] Indicator started",
         " | Symbol=", _Symbol,
         " | StartTime=", TimeToString(indicatorStartTime, TIME_DATE|TIME_SECONDS));
 
   return INIT_SUCCEEDED;
}
 
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
   if(reason == REASON_CHARTCHANGE)
      return;
 
   CleanupIndicatorResources();
 
   Print("[RG DEMO CONFIG 1] Indicator stopped and resources cleaned | Symbol=", _Symbol);
}
 
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[])
{
   datetime firstTime = BuildTodayTime(First_Signal_Time);
 
   if(firstTime <= 0)
      return rates_total;
 
   CheckSlot(1,  firstTime,                                 First_Signal_Action);
   CheckSlot(2,  firstTime + Signal_02_Seconds_After_First, Signal_02_Action);
   CheckSlot(3,  firstTime + Signal_03_Seconds_After_First, Signal_03_Action);
   CheckSlot(4,  firstTime + Signal_04_Seconds_After_First, Signal_04_Action);
   CheckSlot(5,  firstTime + Signal_05_Seconds_After_First, Signal_05_Action);
   CheckSlot(6,  firstTime + Signal_06_Seconds_After_First, Signal_06_Action);
   CheckSlot(7,  firstTime + Signal_07_Seconds_After_First, Signal_07_Action);
   CheckSlot(8,  firstTime + Signal_08_Seconds_After_First, Signal_08_Action);
   CheckSlot(9,  firstTime + Signal_09_Seconds_After_First, Signal_09_Action);
   CheckSlot(10, firstTime + Signal_10_Seconds_After_First, Signal_10_Action);
 
   return rates_total;
}
 
//+------------------------------------------------------------------+
//| Checks if a demo signal must be sent to RiskGuard Config. 1       |
//+------------------------------------------------------------------+
void CheckSlot(int slot, datetime targetTime, RG_CONFIG1_ACTION action)
{
   if(action == ACTION_NONE)
      return;
 
   // Prevent retroactive signals.
   if(targetTime < indicatorStartTime)
      return;
 
   datetime now = TimeCurrent();
 
   // Works in live market and Strategy Tester.
   // The signal is sent at the first available tick after targetTime.
   if(now < targetTime)
      return;
 
   string lastName = LastSignalGVName(slot);
 
   if(GlobalVariableCheck(lastName))
   {
      datetime lastValue = (datetime)GlobalVariableGet(lastName);
 
      if(lastValue == targetTime)
         return;
   }
 
   // Save before sending the command to prevent duplicates.
   GlobalVariableSet(lastName, (double)targetTime);
 
   string actionText = ActionToString(action);
 
   if(actionText == "")
      return;
 
   if(actionText == "BUY")
      SendRiskGuardConfig1Signal("BUY");
 
   else if(actionText == "SELL")
      SendRiskGuardConfig1Signal("SELL");
 
   else if(actionText == "BE")
      SendRiskGuardConfig1Signal("BE");
 
   else if(actionText == "CLOSE")
      SendRiskGuardConfig1Signal("CLOSE");
 
   Print("[RG DEMO CONFIG 1] Signal sent",
         " | Slot=", slot,
         " | TargetTime=", TimeToString(targetTime, TIME_DATE|TIME_SECONDS),
         " | Action=", actionText,
         " | Symbol=", _Symbol);
}
 
//+------------------------------------------------------------------+
string ActionToString(RG_CONFIG1_ACTION action)
{
   if(action == ACTION_BUY)
      return "BUY";
 
   if(action == ACTION_SELL)
      return "SELL";
 
   if(action == ACTION_BE)
      return "BE";
 
   if(action == ACTION_CLOSE)
      return "CLOSE";
 
   return "";
}
 
//+------------------------------------------------------------------+
string LastSignalGVName(int slot)
{
   return "RG_Demo_Config1_LastSignal_" + _Symbol + "_" + IntegerToString(slot);
}
 
//+------------------------------------------------------------------+
void CleanupIndicatorResources()
{
   for(int i = 1; i <= 10; i++)
      GlobalVariableDel(LastSignalGVName(i));
 
   // Delete here any graphic object created by this indicator.
   // Example:
   // ObjectDelete(0, "RG_Demo_Config1_Box");
   // ObjectDelete(0, "RG_Demo_Config1_Label");
}
 
//+------------------------------------------------------------------+
datetime BuildTodayTime(string signalTime)
{
   string parts[];
   int count = StringSplit(signalTime, ':', parts);
 
   if(count != 3)
   {
      Print("[RG DEMO CONFIG 1] Invalid time format: ", signalTime,
            " | Correct format: HH:MM:SS");
      return 0;
   }
 
   int h = (int)StringToInteger(parts[0]);
   int m = (int)StringToInteger(parts[1]);
   int s = (int)StringToInteger(parts[2]);
 
   if(h < 0 || h > 23 || m < 0 || m > 59 || s < 0 || s > 59)
   {
      Print("[RG DEMO CONFIG 1] Invalid time value: ", signalTime);
      return 0;
   }
 
   MqlDateTime dt;
   TimeToStruct(TimeCurrent(), dt);
 
   dt.hour = h;
   dt.min  = m;
   dt.sec  = s;
 
   return StructToTime(dt);
}
 
//+------------------------------------------------------------------+
//| Official RiskGuard signal function  Config. 1                    |
//|                                                                  |
//|                                                                  |
//| DO NOT MODIFY THIS FUNCTION.                                     |
//| This function must remain identical in all RiskGuard-compatible  |
//| indicators.                                                      |
//+------------------------------------------------------------------+
void SendRiskGuardConfig1Signal(string action)
{
   GlobalVariableDel("RG_Strategy_Config1_Buy_" + _Symbol);
   GlobalVariableDel("RG_Strategy_Config1_Sell_" + _Symbol);
   GlobalVariableDel("RG_Strategy_Config1_Close_" + _Symbol);
   GlobalVariableDel("RG_Strategy_Config1_Be_" + _Symbol);
 
   if(action == "BUY")
      GlobalVariableSet("RG_Strategy_Config1_Buy_" + _Symbol, 1);
 
   else if(action == "SELL")
      GlobalVariableSet("RG_Strategy_Config1_Sell_" + _Symbol, 1);
 
   else if(action == "CLOSE")
      GlobalVariableSet("RG_Strategy_Config1_Close_" + _Symbol, 1);
 
   else if(action == "BE")
      GlobalVariableSet("RG_Strategy_Config1_Be_" + _Symbol, 1);
 
   else
      Print("[RG CONFIG 1] Invalid action: ", action);
}
//+------------------------------------------------------------------+