Pattern di Spike Bullish nel Boom Index: Guida per MetaTrader 5

Se sei un trader attivo nel mercato dei Boom Index, probabilmente hai notato come i pattern di spike possano offrire ottime opportunità di trading. In questo post, esploreremo il Pattern di Spike Bullish e come utilizzarlo efficacemente con MetaTrader 5.

Riconoscimento del Pattern di Spike Bullish

Il pattern è composto da 3 candele:
- 1ª candela: Verde con corpo ampio (spike bullish).
- 2ª candela: Rossa (ritracciamento).
- 3ª candela: Verde con corpo ampio (nuovo spike bullish).
Quando questo pattern si presenta, viene creata una zona.

Creazione della Zona

Viene disegnato un rettangolo blu che rappresenta l'intervallo massimo/minimo delle 3 candele.
Viene disegnata una linea orizzontale di ingresso lime green al prezzo di apertura della candela centrale (2ª candela).
La linea si estende nel futuro fino a quando il prezzo non torna a colpirla.

Spiegazione degli INPUTS

mq5
input color BoxColor = clrBlue; // Colore del rettangolo del pattern delle 3 candele
input color EntryLineColor = clrLime; // Colore della linea di ingresso
input ENUM_LINE_STYLE EntryLineStyle = STYLE_SOLID; // Stile della linea di ingresso
input int BoxWidth = 2; // Larghezza del bordo del rettangolo
input int EntryLineWidth = 2; // Larghezza della linea di ingresso
input int EntryLineLength = 200; // Lunghezza della linea di mitigazione

Questi input ti permettono di controllare completamente lo stile del rettangolo e della linea di ingresso.

Concetto Fondamentale

Stiamo cercando un pattern bullish formato da 3 candele:

1. Prima candela – bullish forte (spike)

2. Seconda candela – ritracciamento bearish

3. Terza candela – spike bullish forte di nuovo

Quando appare questo schema, disegniamo:

- Un rettangolo attorno al pattern

- Una linea orizzontale al prezzo di apertura della 2ª candela (punto d'ingresso)

Una volta che il prezzo torna a quella linea ("mitigazione"), accorciamo la linea e evitiamo di ridisegnarla.

Strutture Dati

struct PatternInfo {
	datetime time; // Tempo del pattern
	double entry; // Prezzo di ingresso (apertura della 2ª candela)
	double high; // Massimo massimo delle 3 candele
	double low; // Minimo minimo delle 3 candele
	bool mitigated; // Il prezzo è tornato al livello di ingresso?
};
CArrayObj activePatterns;

Utilizziamo una struttura PatternInfo per tenere traccia di ogni pattern valido e memorizzarlo in un array. Questo aiuta a evitare elaborazioni ripetute.

Funzione di Inizializzazione

int OnInit() {
	IndicatorSetInteger(INDICATOR_DIGITS, _Digits);
	ArrayInitialize(activePatterns, 0);
	return INIT_SUCCEEDED;
}

Impostiamo la precisione dell'indicatore e prepariamo il nostro array.

Rilevamento del Pattern (Ad Ogni Tick)

for (int i = limit - 3; i >= 0; i--) {
	if (isBullish(i + 2) && isBearish(i + 1) && isBullish(i)) {
		double high = MathMax(MathMax(High[i], High[i + 1]), High[i + 2]);
		double low = MathMin(MathMin(Low[i], Low[i + 1]), Low[i + 2]);
		double entry = Open[i + 1];
		PatternInfo *pattern = new PatternInfo;
		pattern.time = Time[i];
		pattern.entry = entry;
		pattern.high = high;
		pattern.low = low;
		pattern.mitigated = false;
	}
}

Creiamo e aggiungiamo questo pattern alla nostra lista.

Disegnare il Rettangolo e la Linea

string boxName = "Box_" + IntegerToString(Time[i]);
ObjectCreate(0, boxName, OBJ_RECTANGLE, 0, Time[i + 2], high, Time[i], low);
string lineName = "EntryLine_" + IntegerToString(Time[i]);
ObjectCreate(0, lineName, OBJ_TREND, 0, Time[i], entry, Time[i] + PeriodSeconds() * EntryLineLength, entry);

Disegniamo il rettangolo (box) dal pattern delle 3 candele e la linea di ingresso dalla apertura della 2ª candela in avanti nel tempo.

Controllo della Mitigazione (Ad Ogni Tick)

for (int p = 0; p < activePatterns.Total(); p++) {
	PatternInfo *pt = (PatternInfo*)activePatterns.At(p);
	if (!pt.mitigated && Low[0] <= pt.entry) {
		pt.mitigated = true;
		ObjectDelete("EntryLine_" + IntegerToString(pt.time));
		ObjectCreate(0, "MitigatedLine_" + IntegerToString(pt.time), OBJ_TREND, 0,
		pt.time, pt.entry,
		Time[0], pt.entry);
	}
}

Se il prezzo attuale colpisce il livello di ingresso, segniamo la mitigazione e cancelliamo la linea originale.

Funzioni di Aiuto

bool isBullish(int i) {
	return Close[i] > Open[i];
}
bool isBearish(int i) {
	return Close[i] < Open[i];
}

Questo indicatore è semplice ma potente:

Riconosce il vero comportamento di spike nel Boom
Visualizza gli ingressi del denaro intelligente
Rileva automaticamente la mitigazione

Ora puoi testarlo dal vivo su Boom 500 o Boom 1000.

Se hai domande o vuoi condividere le tue esperienze, lascia un commento qui sotto!