Vom Neuling zum Experten: Navigieren durch die Unregelmäßigkeiten des Marktes

Inhalt

1. Einführung
2. Umsetzung
3. Tests
4. Schlussfolgerung
5. Wichtige Erkenntnisse
6. Anlagen

Einführung

Die meisten Anfänger machen sich schon früh in ihren Marktstudien mit Unterstützung und Widerstand vertraut. Dies liegt vor allem daran, dass das Konzept in der Handelsliteratur und in Online-Ressourcen weithin zugänglich ist und ausführlich diskutiert wird. Obwohl dieses Grundwissen wertvoll ist, hat das übermäßige Vertrauen in statische Unterstützungs- und Widerstandszonen viele Händler aus dem Spiel gedrängt, da sich das Marktverhalten ständig weiterentwickelt.

Märkte sind von Natur aus dynamisch. Einst zuverlässig erscheinende Niveaus können an Wirksamkeit verlieren, wenn die Volatilität zunimmt und die Preisstruktur unregelmäßig wird. Heute gehen wir diese Herausforderung an, indem wir einen auf MQL5 basierenden algorithmischen Ansatz einführen, der dynamische Unterstützungs- und Widerstandszonen anstelle von festen Preislinien identifiziert. Diese Innovation verbessert den Handel der traditionellen Unterstützungs- und Widerstandsbereiche, indem sie eine manuelle, statische Technik in ein kontinuierlich adaptives, regelbasiertes System umwandelt.

Indem der Algorithmus die Fähigkeit des Computers zur Verarbeitung von Zeitreihendaten nutzt, berechnet er diese Zonen bei jedem Tick neu und aktualisiert sie in Echtzeit. Das Ergebnis ist ein vollständig dynamischer Rahmen, der sicherstellt, dass keine Gelegenheit verpasst wird, auch wenn sich die Marktbedingungen schnell ändern.

Problem: Rechtfertigung

Die Behandlung von Unterstützung oder Widerstand als eine einzige horizontale Linie kann unter sauberen Marktbedingungen effektiv sein, versagt aber oft bei unruhigen oder sich verändernden Marktstrukturen. In einem solchen Umfeld werden Händler häufig vorzeitig ausgestoppt, Aufträge bleiben unausgeführt oder sie zögern, weil sie unsicher sind, ob eine Konstellation halten wird.

Unsere Lösung behebt diese Einschränkung, indem wir Unterstützung und Widerstand als Wahrscheinlichkeitszonen und nicht als präzise Preisniveaus neu definieren. Diese Zonen stellen Bereiche dar, in denen eine Preisinteraktion statistisch gesehen wahrscheinlicher ist, was die Chancen auf eine Auftragsausführung erhöht und gleichzeitig das emotionale Zögern und das Risiko langfristiger Drawdowns verringert.

Auch ohne Bestätigung durch Oszillatoren – wie z. B. den RSI – erhöht die zur Berechnung dieser Zonen verwendete Aggregationslogik ihre Zuverlässigkeit. Im nächsten Unterabschnitt werden wir die konzeptionellen Grundlagen dieses Ansatzes erkunden, bevor wir in den Abschnitt über die Implementierung übergehen, in dem wir die Idee mit MQL5 in die Praxis umsetzen.

Verstehen des Konzepts der Wahrscheinlichkeitszonen

Wie bei den meisten meiner Arbeiten begann auch diese Idee damit, ein manuelles Handelskonzept in eine algorithmische Lösung zu übertragen. Mein Entwicklungsprozess beginnt oft auf einem Chart des MetaTrader 5, wo die visuelle Analyse wiederkehrende Probleme aufdeckt, die mit den umfangreichen algorithmischen Möglichkeiten von MQL5 programmatisch angegangen werden können.

Bei der Analyse der Preisentwicklung bin ich immer wieder auf unruhige Marktbedingungen gestoßen – viel häufiger als auf saubere Lehrbuch-Konstellationen. Dies warf eine wichtige Frage auf: Wie können wir die Zeit reduzieren, die wir mit dem Warten auf „perfekte“ Konstellationen verbringen, wenn der Markt sie nur selten bietet?

Selbst eine lange Geduld kann zu Enttäuschungen führen, da viele Konstellationen erst dann gültig werden, wenn die Gelegenheit bereits verstrichen ist. Um dem entgegenzuwirken, benötigen wir eine Lösung, die eine Bandbreite an Wahrscheinlichkeiten bietet und es den Händlern ermöglicht, von besseren Positionen aus zu partizipieren, anstatt zu spät zu reagieren. Dieser Ansatz ermöglicht auch eine genauere Risikodimensionierung im Verhältnis zum Kontokapital.

Traditionell wird die Unterstützung oder der Widerstand ermittelt, indem mehrere Preisreaktionen zu einem einzigen Niveau gemittelt werden. Jenseits dieser Durchschnittslinie kommt es jedoch häufig zu externen Ausschlägen, die nicht ignoriert werden können. Diese Ausschläge tragen erheblich zur Breite der Unterstützungs- oder Widerstandszone bei und sind eine Hauptursache für Marktschwankungen, die manchmal auf institutionelle Aktivitäten oder Liquiditätsschwankungen zurückgeführt werden.

Während das genaue Verhalten der großen Marktteilnehmer ungewiss bleibt, ist die daraus resultierende ungleiche Preisstruktur unbestreitbar und untergräbt oft das Vertrauen der Händler. Die in diesem Artikel vorgestellte Lösung konzentriert sich darauf, dieses Vertrauen wiederherzustellen, indem die Unvollkommenheit des Marktes angenommen wird, anstatt sie zu bekämpfen.

Das folgende Diagramm veranschaulicht dieses Kernkonzept. Die externen Spitzen, die oft als Rauschen oder Manipulation abgetan werden, sind ein wesentlicher Bestandteil der Definition der wahren Zone. Unser Algorithmus ignoriert sie nicht, sondern nutzt sie zur Berechnung der robusten Grenzen des Marktinteresses.

Abb. 1. Beobachtungen aus der historischen Preisanalyse

Um dieses Konzept anschaulich zu erläutern, habe ich den USDJPY auf dem H1-Zeitrahmen verwendet und bewusst durch die historischen Kursdaten zurückgeblättert. Es handelte sich nicht um einen Echtzeithandel. Mein Ziel in dieser Phase war eine reine Strukturanalyse – ich wollte untersuchen, wie sich die Kurse im Laufe der Zeit um Unterstützungen und Widerstände herum verhalten, ohne den Druck einer Live-Ausführung.

Indem ich mich durch vergangene Kerzen bewegte, konnte ich objektiv wiederholte Reaktionen beobachten und Muster erkennen, die beim Handel in Echtzeit oft übersehen werden.

1. Kennzeichnung der extremen Preisablehnungen

Bei der Untersuchung des Chartverlaufs habe ich mich zunächst auf die extremsten Kursbewegungen konzentriert.

An der oberen Grenze habe ich eine Linie gezogen, die ich als extremen Widerstand (extreme resistance) bezeichne. Auf diesem Niveau wurden die höchsten Aufwärtsspitzen erfasst, bei denen der Preis wiederholt abgelehnt wurde. Zum Beispiel ist der Kurs am Punkt B in diesen Bereich gestiegen und hat sofort wieder umgeschlagen. Der Preis erreichte zwar gelegentlich dieses Niveau, blieb aber nie lange dort. Dies sagte mir, dass diese Region die obere Grenze der Marktakzeptanz darstellte, nicht aber einen genauen Handelseinstieg.

An der unteren Begrenzung habe ich eine extreme Unterstützung (extreme support) markiert. Am Punkt A kam es zu einem starken Preisrückgang, bevor die Käufer aggressiv eingriffen. Diese tief nach unten gerichteten Spitzen waren selten, aber wenn sie auftraten, bildeten sie die unterste Grenze der Struktur.

2. Ermittlung des durchschnittlichen Reaktionsniveaus

Als Nächstes habe ich, immer noch anhand historischer Daten, nach Bereichen gesucht, in denen der Preis am häufigsten reagierte, nicht nur dort, wo er am aggressivsten reagierte.

Ich habe eine durchschnittliche Widerstandslinie erstellt, indem ich mehrere Reaktionspunkte wie d, e und f zusammengefasst habe. Der Kurs kam wiederholt um dieses Niveau herum zum Stillstand oder kehrte um, auch wenn er manchmal in Richtung des extremen Widerstands anstieg.

In ähnlicher Weise habe ich die durchschnittliche Unterstützung durch die Beobachtung wiederholter Abpraller an den Punkten g, h, i und j ermittelt. Dieses Niveau wurde viel häufiger getestet als die extreme Unterstützung und diente eindeutig als zentraler Nachfragebereich.

Dieser Schritt hat mir etwas klar gemacht: Der Markt respektiert Preisspannen, nicht einzelne exakte Zahlen.

Verstehen der Zonenstruktur

Sobald alle vier Linien platziert waren, ergab sich die Struktur von selbst.

Zwischen dem durchschnittlichen Widerstand und dem extremen Widerstand kam es häufig zu Kursausschlägen, Abwertungen und Konsolidierungen. Das gleiche Verhalten zeigte sich zwischen durchschnittlicher Unterstützung und extremer Unterstützung. Diese Regionen bildeten Unterstützungs- und Widerstandszonen, nicht aufgrund einer Theorie, sondern aufgrund des wiederholten historischen Verhaltens.

Was viele Händler als „falsche Ausbrüche“ bezeichnen, waren einfach nur Kurse, die die äußeren Ränder dieser Zonen testeten. Nachdem ich die Extrem- und Durchschnittswerte durch Scrollen durch die historischen Kursdaten ermittelt hatte, ging ich einen Schritt weiter und wandelte diese Linien in Zonen um. An dieser Stelle wurde die Idee wirklich praktisch. Anstatt die Struktur als vier isolierte horizontale Linien zu belassen, habe ich den Raum zwischen ihnen mit Rechtecken markiert, um visuell darzustellen, wie das System in der Praxis funktionieren soll. Siehe die nachstehende Abbildung, Abb. 2.

Abb. 2. Wahrscheinliche Unterstützungs- und Widerstandszonen mit gefüllten Rechtecken markiert

Bei der Beobachtung des Kursgeschehens innerhalb dieses Rechtecks fielen mir mehrere Dinge deutlich auf. Der Kurs brauchte nicht genau den extremen Widerstand zu berühren, um zu reagieren. In zahlreichen Fällen kam es zu Reaktionen innerhalb der Zone, wie bei den Punkten d, e und f zu sehen ist. Gelegentlich schoss der Preis tiefer in die Zone hinein – wie etwa bei Punkt B –, aber diese Ausschläge waren nur von kurzer Dauer und wurden schnell wieder verworfen.

In der algorithmischen Version:

1. Das System berechnet die durchschnittlichen und extremen Grenzen.
2. Es zeichnet Zonen dynamisch mit Rechtecken
3. Die Preisinteraktion wird innerhalb der Zone bewertet, nicht an einer einzelnen Linie
4. Trades, Warnungen oder Bestätigungen können auf der Grundlage von Regeln für die Interaktion mit der Zone ausgelöst werden.

Obwohl dieses Beispiel auf einer historischen Analyse beruht, definiert es eindeutig die Logik, die nach der Implementierung in MQL5 in Echtzeit funktionieren kann. Nachdem ich die Unterstützungs- und Widerstandszonen definiert und mit Rechtecken markiert hatte, scrollte ich im gleichen historischen Abschnitt weiter, um zu beobachten, wie der Preis schließlich mit diesen Zonen interagierte. Ich habe die Struktur nicht verändert und die Zonen nicht neu gezeichnet – ich habe einfach beobachtet, wie sich der Preis verhielt, sobald er die Grenzen wieder erreicht hatte. Dieser Schritt war wichtig, denn eine Zone sollte nicht nur Ablehnungen erklären, sondern auch Ausbrüche.

Abb. 3: Zonenausbruch

In Abb. 3 konnte ich feststellen, dass der Preis sich der Widerstandszone näherte und wiederholt versuchte, nach oben zu steigen, aber jede Bewegung kam zunächst innerhalb des schattierten Bereichs zum Stillstand. Dieses Verhalten zeigte eine deutliche Kompression – die Käufer absorbierten allmählich den Druck der Verkäuferseite innerhalb der Zone, anstatt sofort zurückgewiesen zu werden.

Anstatt diese fehlgeschlagenen Vorstöße als falsche Signale zu betrachten, interpretierte ich sie als Druckaufbau innerhalb der Zone. Eine Zone lehnt den Preis nicht sofort ab; sie enthält den Preis, bis eine Seite erschöpft ist.

Schließlich brach der Kurs klar über die Widerstandszone aus, was durch den eingekreisten Bereich hervorgehoben wird. Es handelte sich nicht um eine kleine Spitze oder einen Docht oberhalb einer Linie. Es handelte sich um eine entscheidende Expansion mit starken Aufwärtskerzen, die deutlich über der oberen Begrenzung der Zone schlossen.

Was mir auffiel, war, dass der Ausbruch nach einer längeren Interaktion innerhalb der Zone erfolgte, nicht beim ersten Kontakt. Dies bestätigte, dass die Zone ihre Aufgabe bereits erfüllt hatte – sie nahm Aufträge auf und verriet ihre Absichten.

Warum die Zone den Ausbruch deutlicher macht

Hätte ich eine einzige Widerstandslinie verwendet, wäre diese Bewegung vielleicht verwirrend oder sogar irreführend gewesen – war es ein falscher oder ein echter Ausbruch?

Durch die Verwendung einer Widerstandszone wurde der Ausbruch eindeutig:

• Der Kurs hat den gesamten Widerstandsbereich verlassen.
• Momentum über historische Ablehnungsgrenzen hinaus erweitert
• Die Struktur hat sich eindeutig vom Bereich zur Fortsetzung verschoben

Was Sie lernen und erstellen werden

In den folgenden Abschnitten werden wir vom Konzept zum Code übergehen. Wir werden:

1. Dekonstruktion des Algorithmus: Aufschlüsseln der Logik zur Identifizierung von Swing-Punkten, zum Clustern von Berührungen und zur Berechnung des dynamischen Durchschnitts und der Extremwerte.
2. Erstellen des MQL5-Indikators: Schreiben des Codes, der diese Wahrscheinlichkeitszonen in Echtzeit direkt auf Ihr Chart zeichnet, mit einer klaren visuellen Unterscheidung zwischen Unterstützung und Widerstand.
3. Integration in ein Handelssystem: Demonstration der Verwendung dieser algorithmischen Zonen als Grundlage für die Erzeugung von Signalen mit hoher Wahrscheinlichkeit, von der Visualisierung bis zur Ausführung.

Umsetzung

Nachdem wir die konzeptionelle Grundlage der wahrscheinlichkeitsbasierten Unterstützungs- und Widerstandszonen durch die historische Analyse geschaffen haben, gehen wir nun in die Umsetzungsphase über. In diesem Abschnitt setzen wir die manuellen Beobachtungen systematisch in einen strukturierten, wiederholbaren und Echtzeit-MQL5-Indikator um.

Wir versuchen nicht, Preise vorherzusagen, sondern wir beobachten, aggregieren und visualisieren das Marktverhalten. Jeder Implementierungsschritt spiegelt eine bewusste Designentscheidung wider, die das widerspiegelt, was wir zuvor manuell auf der Karte gemacht haben – nur dass es jetzt objektiv und kontinuierlich von der Plattform ausgeführt wird.

1. Strukturelle Grundlage und Nutzerkonfiguration

Jeder robuste MQL5-Indikator beginnt mit klaren Eigenschaftsdeklarationen und konfigurierbaren Parametern. Dadurch wird die Identität des Indikators festgelegt und der Händler erhält wichtige Kontrollmöglichkeiten, um das Tool an verschiedene Instrumente und Zeitrahmen anzupassen.

#property copyright "Copyright 2025, Clemence Benjamin."
#property link      "https://www.mql5.com"
#property version   "1.00"
#property indicator_chart_window
#property indicator_buffers 4
#property indicator_plots   4

//--- Input Parameters (Optimized for M5)
input int    LookBackPeriod   = 150;    // Bars to analyze
input int    SwingSensitivity = 5;      // Swing detection (3-10)
input int    ZonePadding      = 20;     // Zone padding in points
input color  SupportColor     = clrRoyalBlue;   // Support zone color
input color  ResistanceColor  = clrCrimson;     // Resistance zone color
input bool   ShowZoneLabels   = true;   // Show zone labels

//--- Buffers
double SupportHighBuffer[];
double SupportLowBuffer[];
double ResistanceHighBuffer[];
double ResistanceLowBuffer[];

Schlüssel-Design:

1. Platzierung des Chartfensters: Der Indikator zeichnet direkt auf den Kurschart (indicator_chart_window), um einen unmittelbaren visuellen Kontext zu schaffen.
2. Konfigurierbare Empfindlichkeit: Parameter wie SwingSensitivity und LookBackPeriod ermöglichen die Anpassung von Scalping (M1-M5) zu Swing-Trading (H1-H4) Zeitrahmen.
3. Vier Datenpuffer: Jeder Puffer speichert eine Begrenzung unserer beiden Zonen, sodass der Indikator bei Bedarf gestrichelte Begrenzungslinien darstellen kann, obwohl unsere primäre Visualisierung Chart-Objekte verwendet.

2. Erkennen der Kernstruktur des Marktes: Algorithmus der Swing-Punkte

Die Genauigkeit unserer Zonen hängt ganz davon ab, dass wir die wichtigen Wendepunkte des Marktes richtig erkennen. Wir implementieren einen einfachen, aber effektiven Algorithmus zur Erkennung von Schwankungen, der jeden Balken mit seinen unmittelbaren Nachbarn vergleicht.

//+------------------------------------------------------------------+
//| Simple swing high detection                                      |
//+------------------------------------------------------------------+
bool IsSwingHighSimple(int index, int period, const double& high[])
{
   if(index < period || index >= ArraySize(high)-period)
      return false;
   
   double currentHigh = high[index];
   
   for(int i=1; i<=period; i++)
   {
      if(currentHigh <= high[index-i] || currentHigh <= high[index+i])
         return false;
   }
   return true;
}

//+------------------------------------------------------------------+
//| Simple swing low detection                                       |
//+------------------------------------------------------------------+
bool IsSwingLowSimple(int index, int period, const double& low[])
{
   if(index < period || index >= ArraySize(low)-period)
      return false;
   
   double currentLow = low[index];
   
   for(int i=1; i<=period; i++)
   {
      if(currentLow >= low[index-i] || currentLow >= low[index+i])
         return false;
   }
   return true;
}

Diese Funktionen implementieren eine Methode zur Erkennung lokaler Extremwerte. Eine SwingSensitivität von 5 bedeutet, dass ein Balken nur dann als Swing-High angesehen wird, wenn er höher ist als die 5 Balken davor und danach. Dies schafft ein Gleichgewicht zwischen Sensitivität (Erkennen kleinerer Schwankungen) und Signifikanz (Ignorieren von Marktstörungen).

3. Berechnung der Zonen: Von Punkten zu Wahrscheinlichkeitsbereichen

Das Herzstück unseres Systems wandelt diskrete Swing-Punkte in kontinuierliche Wahrscheinlichkeitsbereiche um. Dieser Prozess umfasst die Sammlung gültiger Swing-Punkte, die Bestimmung ihrer Reichweite und die Anwendung von einem intelligenten Padding.

//+------------------------------------------------------------------+
//| Find support and resistance zones                                |
//+------------------------------------------------------------------+
void FindZones(const double& high[], const double& low[], 
               double& supportHigh, double& supportLow,
               double& resistanceHigh, double& resistanceLow)
{
   double supportLevels[], resistanceLevels[];
   ArrayResize(supportLevels, 0);
   ArrayResize(resistanceLevels, 0);
   
   int limit = MathMin(ArraySize(high), LookBackPeriod);
   
   // Find swing points
   for(int i=SwingSensitivity; i<limit-SwingSensitivity; i++)
   {
      if(IsSwingLowSimple(i, SwingSensitivity, low))
      {
         ArrayResize(supportLevels, ArraySize(supportLevels)+1);
         supportLevels[ArraySize(supportLevels)-1] = low[i];
      }
      
      if(IsSwingHighSimple(i, SwingSensitivity, high))
      {
         ArrayResize(resistanceLevels, ArraySize(resistanceLevels)+1);
         resistanceLevels[ArraySize(resistanceLevels)-1] = high[i];
      }
   }
   
   // Calculate support zone
   if(ArraySize(supportLevels) > 0)
   {
      // Find the most recent significant support
      supportHigh = 0;
      supportLow = DBL_MAX;
      
      for(int i=0; i<ArraySize(supportLevels); i++)
      {
         if(supportLevels[i] > supportHigh) supportHigh = supportLevels[i];
         if(supportLevels[i] < supportLow) supportLow = supportLevels[i];
      }
      
      // Adjust for zone
      double zonePadding = ZonePadding * _Point;
      supportHigh += zonePadding * 2;  // Add padding above
      supportLow -= zonePadding;       // Add padding below
   }
   // ... similar logic for resistance zone
}

Details zur Umsetzung:

• Verwaltung dynamischer Arrays: Wir verwenden ArrayResize() um effizient Swing-Punkte zu sammeln, ohne vorher festen Speicher zuzuweisen.
• Strategie des asymmetrischen Paddings: Unterstützungszonen erhalten oberhalb (zonePadding * 2) mehr Raum, während Widerstandszonen unterhalb mehr Raum erhalten. Dies spiegelt das beobachtete Marktverhalten wider, bei dem die Preise dazu neigen, über das Ziel hinauszuschießen, bevor sie sich wieder zurückkehren.
• Überprüfung der Grenzen: Die DBL_MAX und die Null-Initialisierung gewährleisten einen robusten Umgang mit Randfällen, in denen keine Swing-Punkte erkannt werden.

4. Visuelles Präsentationssystem: Zeichnen der freien Zonen

Ein Handelsinstrument muss Informationen sofort und klar vermitteln. Unser Zeichnungssystem erzeugt unterschiedliche visuelle Ebenen, die die Wahrscheinlichkeitsbereiche mit maximaler Klarheit darstellen.

//+------------------------------------------------------------------+
//| Draw support and resistance zones                                |
//+------------------------------------------------------------------+
void DrawZones(double supHigh, double supLow, double resHigh, double resLow)
{
   string name;
   datetime startTime = iTime(_Symbol, _Period, LookBackPeriod);
   datetime endTime = TimeCurrent();
   
   // Delete old objects first
   ObjectsDeleteAll(0, "SZone");
   ObjectsDeleteAll(0, "RZone");
   // ... additional cleanup
   
   // Only draw if we have valid values
   if(supHigh > 0 && supLow > 0 && supHigh > supLow)
   {
      // Draw support zone (filled rectangle)
      name = "SZone_Rect";
      ObjectCreate(0, name, OBJ_RECTANGLE, 0, startTime, supHigh, endTime, supLow);
      ObjectSetInteger(0, name, OBJPROP_COLOR, SupportColor);
      ObjectSetInteger(0, name, OBJPROP_BGCOLOR, SupportColor);
      ObjectSetInteger(0, name, OBJPROP_FILL, true);
      ObjectSetInteger(0, name, OBJPROP_BACK, true);
      ObjectSetInteger(0, name, OBJPROP_WIDTH, 0);
      
      // Draw support average line (middle of zone)
      name = "SZone_Avg";
      ObjectCreate(0, name, OBJ_HLINE, 0, 0, (supHigh + supLow) / 2);
      ObjectSetInteger(0, name, OBJPROP_COLOR, clrWhite);
      ObjectSetInteger(0, name, OBJPROP_STYLE, STYLE_SOLID);
      ObjectSetInteger(0, name, OBJPROP_WIDTH, 2);
      
      // ... boundary lines and labels
   }
   // ... similar drawing for resistance zone
}

Visuelles Hierarchiedesign:

• Erste Ebene: Gefüllte Rechtecke mit OBJPROP_BACK=true sorgen dafür, dass die Preisbewegung über die Zonen hinweg sichtbar bleibt.
• Zweite Ebene: Durchgehende weiße Linien (2 px Breite) zeigen den Reaktionspunkt mit der höchsten Wahrscheinlichkeit an.
• Dritte Ebene: Gestrichelte farbige Grenzen (1px Breite) definieren die Zonenränder.
• Informationsebene: Optionale Textbeschriftungen und eine Statusanzeige in der Chartecke.

5. Echtzeitberechnung: Die Funktion OnCalculate

Die Funktion OnCalculate() des Indikators dient als Hauptverarbeitungsschleife, die bei jedem Tick ausgeführt wird, um sicherzustellen, dass die Zonen mit den Marktentwicklungen Schritt halten.

//+------------------------------------------------------------------+
//| Indicator iteration function                                     |
//+------------------------------------------------------------------+
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[])
{
   // Check if we have enough data
   if(rates_total < LookBackPeriod + SwingSensitivity * 2)
      return(0);
   
   // Set arrays as series
   ArraySetAsSeries(high, true);
   ArraySetAsSeries(low, true);
   
   // Find zones
   double supHigh, supLow, resHigh, resLow;
   FindZones(high, low, supHigh, supLow, resHigh, resLow);
   
   // Fill buffers
   int limit = MathMin(rates_total, LookBackPeriod);
   for(int i=0; i<limit; i++)
   {
      SupportHighBuffer[i] = supHigh;
      SupportLowBuffer[i] = supLow;
      ResistanceHighBuffer[i] = resHigh;
      ResistanceLowBuffer[i] = resLow;
   }
   
   // Draw zones on chart
   DrawZones(supHigh, supLow, resHigh, resLow);
   
   // Also publish to global variables for EA access
   if(supHigh > 0 && supLow > 0 && resHigh > 0 && resLow > 0)
   {
      GlobalVariableSet("GLOBAL_SUPPORT_HIGH", supHigh);
      GlobalVariableSet("GLOBAL_SUPPORT_LOW", supLow);
      // ... additional global variables
      GlobalVariableSet("GLOBAL_ZONES_TIME", TimeCurrent());
   }
   
   return(rates_total);
}

Optimierungen in der Verarbeitung:

• Effiziente Array-Verarbeitung: ArraySetAsSeries(true) optimiert die Zugriffsmuster, indem das Arrayelement 0 als der jüngste Takt indiziert wird.
• Pufferzuweisungen: Während Chart-Objekte die primäre Visualisierung liefern, ermöglicht das Auffüllen von Indikatorpuffern eine mögliche Backtesting-Integration.
• Verbindung zu den globalen Variablen: Das Speichern von berechneten Zonen in globalen Variablen (GlobalVariableSet()) schafft eine Schnittstelle für Expert Advisors, um programmatisch auf Zonendaten zuzugreifen, was automatisierte Handelsstrategien ermöglicht.

6. Systemintegration und -bereinigung

Professionelle MQL5-Programmierung erfordert ein sorgfältiges Ressourcenmanagement. Die Initialisierungs- und Deinitialisierungsfunktionen gewährleisten eine ordnungsgemäße Einrichtung und Bereinigung.

//+------------------------------------------------------------------+
//| Indicator initialization function                                |
//+------------------------------------------------------------------+
int OnInit()
{
   // Set buffer properties
   SetIndexBuffer(0, SupportHighBuffer, INDICATOR_DATA);
   // ... buffer setup for all four buffers
   
   // Set plotting properties
   PlotIndexSetInteger(0, PLOT_DRAW_TYPE, DRAW_LINE);
   PlotIndexSetInteger(0, PLOT_LINE_STYLE, STYLE_DASH);
   PlotIndexSetInteger(0, PLOT_LINE_COLOR, SupportColor);
   // ... similar setup for other plots
   
   IndicatorSetString(INDICATOR_SHORTNAME, "Dynamic S/R Zones");
   IndicatorSetInteger(INDICATOR_DIGITS, _Digits);
   
   return(INIT_SUCCEEDED);
}

//+------------------------------------------------------------------+
//| Indicator deinitialization function                              |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
   // Clean up all objects
   ObjectsDeleteAll(0, "SZone");
   ObjectsDeleteAll(0, "RZone");
   ObjectsDeleteAll(0, "Sup");
   ObjectsDeleteAll(0, "Res");
   ObjectsDeleteAll(0, "ZoneInfo");
   
   // Clean up global variables
   GlobalVariableDel("GLOBAL_SUPPORT_HIGH");
   // ... delete all related global variables
}

Strategie der Ressourcenverwaltung:

• Konfiguration von OnInit(): Es werden alle Indikatoreigenschaften in einer einzigen, übersichtlichen Funktion konfiguriert.
• Umfassende Bereinigung: OnDeinit() entfernt jedes Chart-Objekt und jede globale Variable, die durch den Indikator erstellt wurden, und verhindert so Unordnung im Chart und Speicherlecks, wenn der Indikator entfernt wird.

Tests

Ein interessantes Ergebnis des von uns entwickelten Indikators ist seine Fähigkeit, direkt im Strategietester des MetaTrader 5 ausgewertet zu werden. Diese Fähigkeit ermöglicht es uns, die Logik nicht nur durch visuelle, diskretionäre Beobachtung auf Live-Charts zu validieren, sondern auch durch strukturierte Tests in einer kontrollierten, historischen Umgebung. Wir stellen sicher, dass dieselbe Berechnungslogik und dieselben Zeichenroutinen sowohl in Echtzeit als auch unter simulierten Bedingungen konsistent ausgeführt werden, was für eine objektive Überprüfung unerlässlich ist.

Wir haben den Indikator in Echtzeit getestet, um zu beobachten, wie sich die Wahrscheinlichkeitszonen für Unterstützung und Widerstand entwickeln, wenn neue Kursdaten verfügbar werden. Parallel dazu haben wir mit dem Strategietester des MetaTrader 5 historische Marktdaten wiedergegeben, um zu untersuchen, wie der Preis in der Vergangenheit mit diesen Zonen interagiert hat. Mit diesem Dual-Mode-Testing-Ansatz können wir bestätigen, dass die Zonen nicht rückwärtsgerichtet sind und sie sich dynamisch anpassen, wenn sich der Preis Kerze für Kerze entwickelt.

In den unten dargestellten historischen Tests können wir deutlich beobachten, wie die Preise die identifizierten Zonen respektieren, während sich der Markt entfaltet. Kursreaktionen wie Pausen, Zurückweisungen und kurze Konsolidierungen treten wiederholt um die hervorgehobenen Bereiche herum auf, was die Gültigkeit der erkannten Unterstützungs- und Widerstandsbereiche unterstreicht. Dieses Verhalten ist über verschiedene Segmente der getesteten Daten hinweg konsistent, was unser Vertrauen in die Robustheit der Logik stärkt.

Abb. 4: Visuelles Testen des Indikators im Strategietester.

Insgesamt sind die Testergebnisse vielversprechend und lassen darauf schließen, dass der Indikator eine zuverlässige Grundlage für eine auf Unterstützung und Widerstand basierende Handelsstrategie bietet. Obwohl weitere Tests und eine Verfeinerung der Parameter stets empfohlen werden, zeigen die aktuellen Ergebnisse, dass die Zonen sowohl für Analyse- als auch für Handelszwecke aussagekräftig, stabil und praktisch sind.

Schlussfolgerung

Es ist durchaus möglich, komplexe Marktstrukturen durch den Einsatz von wahrscheinlichkeitsbasierten Zonen innerhalb eines strukturierten Handelsrahmens zu steuern. In dieser Diskussion haben wir gezeigt, wie abstrakte, manuell angewandte Unterstützungs- und Widerstandskonzepte in präzise, regelbasierte Algorithmen umgesetzt werden können. Auf diese Weise haben wir die Lücke zwischen der diskretionären Chartanalyse und der systematischen Entwicklung von Indikatoren geschlossen.

Wir untersuchten den gesamten Entwicklungspfad – von der konzeptionellen Marktstrukturlogik bis zu einem voll funktionsfähigen nutzerdefinierten Indikator – und zeigten auf, wie Wahrscheinlichkeitszonen abgeleitet, visualisiert und anhand historischer und Echtzeitdaten validiert werden können.

Das daraus resultierende Tool ermöglicht eine klare und konsistente Identifizierung von Unterstützungs- und Widerstandswahrscheinlichkeitszonen, wodurch die Subjektivität verringert und die analytische Sicherheit bei der Entscheidungsfindung verbessert wird.

Obwohl die derzeitige Implementierung noch keine vollständige Automatisierung des Handels beinhaltet, bietet sie bereits einen praktischen Nutzen als Entscheidungshilfe. Händler können diese Zonen nutzen, um neben anderen technischen Signalen die Handelslokalisierung, das Risikomanagement und die Konfluenzanalyse zu verbessern.

Die Ergebnisse des Strategietesters unterstreichen die Robustheit des Ansatzes, da sie zeigen, dass die Preise diese Zonen häufig respektieren, wenn sich die Marktstruktur entwickelt.

In Zukunft wollen wir diese Arbeit durch die Automatisierung von Zonenaktualisierungen, die Hinzufügung einer probabilistischen Gewichtung auf der Grundlage historischer Reaktionen und die Integration einer direkten Handelsausführungslogik erweitern. Diese Verbesserungen werden den Indikator von einem analytischen Hilfsmittel in eine vollständige, regelbasierte Handelskomponente verwandeln, die für Expert Advisors geeignet ist.

Im Anschluss an diese Schlussfolgerung fassen wir die wichtigsten Erkenntnisse zusammen und stellen den vollständigen Quellcode zur Verfügung. Wir freuen uns über Fragen, Rückmeldungen und offene Diskussionen in den Kommentaren, denn ein gemeinsamer Dialog ist unerlässlich, um Ideen zu verfeinern und praktische Handelslösungen voranzubringen.

Wichtige Erkenntnisse

Wichtige Lektion	Beschreibung:
Unterstützung und Widerstand können als Zonen behandelt werden.	Wir behandeln Unterstützung und Widerstand als Preisbereiche, die sich aus wiederholten Wechselwirkungen ergeben, und nicht als einzelne horizontale Linien. Dies hilft Händlern, in Wahrscheinlichkeiten zu denken, und verbessert die Entscheidungsfindung in Bezug auf Einstiegsmöglichkeiten, Stopps und Ziele.
Die Schwingungsstruktur bestimmt den Marktkontext.	Indem wir die Höchst- und Tiefststände direkt aus den Kursdaten ermitteln, unterstreichen wir die Bedeutung der Marktstruktur gegenüber nachlaufenden Indikatoren. Händler lernen, wie Trendverhalten und Reaktionen gültige Handelsbereiche definieren.
MQL5-Indikatoren folgen einem strengen Lebenszyklus.	Wir zeigen, wie OnInit, OnCalculate und OnDeinit in MQL5 zusammenarbeiten. Das Verständnis dieses Lebenszyklus hilft Händlern und Entwicklern, stabile Indikatoren zu erstellen, die sich in Live-Charts und im Strategietester korrekt verhalten.
Puffer ermöglichen die Integration von Strategien.	Auch bei der Verwendung von Chart-Objekten für die Visualisierung bleiben Indikatorpuffer unverzichtbar. Händler lernen, wie Puffer es Expert Advisors und anderen Tools ermöglichen, die Indikatorlogik programmatisch zu nutzen.
Globale Variablen ermöglichen die EA-Kommunikation.	Die Veröffentlichung von Zonenwerten über globale Variablen zeigt, wie Indikatoren den Marktkontext mit Expert Advisors teilen können, was automatisierte Handelsentscheidungen auf der Grundlage von Strukturanalysen ermöglicht.
Asymmetrisches Padding der Zonen spiegelt die Marktpsychologie wider.	Durch das Padding oberhalb der Unterstützung und unterhalb des Widerstands wird der Tatsache Rechnung getragen, dass die Märkte dazu neigen, über das Ziel hinauszuschießen, bevor sie sich wieder erholen. Diese technische Anpassung erfasst das reale Verhalten der Händler und reduziert falsche Ausbrüche.
Chart-Objekte müssen ordnungsgemäß gelöscht werden.	Die Verwendung von ObjectsDeleteAll() mit bestimmten Präfixen verhindert Speicherlecks und Unordnung in der Tabelle. Diese disziplinierte Herangehensweise ist entscheidend für die professionelle Entwicklung von Indikatoren und die langfristige Stabilität des Charts.
Die Optimierung von Parametern erfordert Kontextbewusstsein.	Die optimale SwingSensitivity und LookBackPeriod variieren je nach Zeitrahmen und Volatilität. Erfolgreiche Händler lernen, diese an die Marktbedingungen anzupassen, anstatt nach universellen „perfekten“ Einstellungen zu suchen.
Die visuelle Hierarchie verbessert die Handelsentscheidungen.	Die Verwendung von durchgezogenen Linien für Durchschnittswerte, gestrichelten Linien für Grenzen und gefüllten Rechtecken schafft ein unmittelbares visuelles Verständnis. Dieser Ansatz hilft Händlern, komplexe Informationen in schnellen Märkten schnell zu verarbeiten.
Wahrscheinlichkeitszonen verringern den emotionalen Handel.	Durch die Angabe eines definierten Bereichs anstelle eines präzisen Preises verringern die Zonen die Angst vor dem „Verpassen des exakten Niveaus“ und helfen den Händlern, sich auf das Risiko-Ertrags-Verhältnis innerhalb statistisch signifikanter Bereiche zu konzentrieren.
Die modulare Codestruktur ermöglicht einfache Erweiterungen.	Die Trennung von Swing-Erkennung, Zonenberechnung und Visualisierungsfunktionen ermöglicht künftige Upgrades wie das Hinzufügen von Volumenbestätigungen oder Multi-Zeitrahmen-Analysen, ohne dass der gesamte Indikator neu geschrieben werden muss.
Echtzeitverarbeitung erfordert Effizienz.	Die Struktur der Funktion OnCalculate mit frühzeitigen Beendigungen bei unzureichenden Daten und ordnungsgemäßem Umgang mit Array-Serien stellt sicher, dass der Indikator auch auf niedrigeren Zeitrahmen bei hoher Volatilität ansprechbar bleibt.

Anlagen

Quelle Dateiname	Version	Beschreibung:
SRProbabilityZones.mq5	1.0	Kernindikator, der Unterstützung und Widerstand nicht als statische Linien, sondern als wahrscheinlichkeitsbasierte Zonen dynamisch berechnet und visualisiert. Es identifiziert algorithmisch Hochs und Tiefs innerhalb eines nutzerdefinierten Rückblickzeitraums, clustert diese Preisinteraktionen und zeichnet deutliche farbige Rechtecke (blau für Unterstützung, rot für Widerstand) auf dem Chart. Die Grenzen der Zonen stellen den Bereich der wahrscheinlichen Preisreaktion dar, wobei eine durchgezogene weiße Linie den wahrscheinlichen Durchschnitt innerhalb jeder Zone markiert. Der Indikator wird bei jedem Tick aktualisiert und veröffentlicht seine berechneten Werte in globalen Variablen zur Integration in Expert Advisors. Tipp: Nach dem Herunterladen des SRProbabilityZones.mq5-Quellcodes können Sie ihn im MetaEditor kompilieren und an ein beliebiges Chart des MetaTrader 5 anhängen, um sofort dynamische Unterstützungs- und Widerstands-Wahrscheinlichkeitszonen zu visualisieren.

Zurück zum Inhalt