Adaptive Smart Money Architektur (ASMA): Verschmelzung von SMC-Logik und Marktstimmung für dynamische Strategie-Wechsel

Inhaltsverzeichnis

1. Einführung
2. Überblick über die Strategie
3. Die ersten Schritte
4. Backtest-Ergebnisse
5. Schlussfolgerung

Einführung

In den letzten Entwicklungsphasen haben wir erfolgreich Orderblöcke (OB), Fair-Value-Gaps (FVG) und Strukturbrüche (BoS) in einem einheitlichen System des Smart-Money-Konzepts kombiniert – ein leistungsstarker Rahmen, der in der Lage ist, institutionelle Preisbewegungen präzise zu lesen. Darauf aufbauend haben wir auch einen individuellen Marktstimmungsindikator entwickelt, der Trendstärke, Volatilität und Momentumausrichtung interpretiert, um den Markt in steigende, fallende oder neutrale Zustände zu kategorisieren. Diese beiden Fortschritte bieten uns nun die perfekte Möglichkeit, strukturelle Preisaktionen mit Echtzeit-Stimmungen in einem einzigen adaptiven Handelssystem zu vereinen.

In der nächsten Phase geht es darum, einen intelligenten EA zu erstellen, der dynamisch zwischen den Strategien wechselt, je nachdem, was der Markt gerade tut. Anstatt sich auf ein festes Muster zu verlassen, nutzt der EA unseren Stimmungsindikator, um das vorherrschende Regime zu bestimmen und die entsprechende OB-, BoS- oder FVG-Strategie zu aktivieren. In Aufwärts-Bedingungen kann es BoS-Fortsetzungs-Konstellationen bevorzugen; während Umkehrungen kann es OB-basierte Ablehnungen bevorzugen; und in Kompressionsumgebungen kann es zur FVG-Logik der Rückkehr zum Mittelwert wechseln. Durch die Verbindung von struktureller Logik und stimmungsgesteuerter Anpassungsfähigkeit kommen wir dem Aufbau eines Handelssystems näher, das genau so reagiert, sich weiterentwickelt und positioniert, wie es ein erstklassiger institutioneller Händler tun würde.

Überblick über die Strategie: Marktsentiment-gesteuertes SMC-Handelssystem

Dieses intelligente Handelssystem integriert drei Kernstrategien des Smart-Money-Concept (SMC) – Orderblöcke (OB), Fair-Value-Gaps (FVG) und Strukturbrüche (BoS) – mit einer Echtzeit-Analyse der Marktstimmung, um einen adaptiven, kontextabhängigen Handelsalgorithmus zu entwickeln. Das System arbeitet auf einem Multi-Timeframe-System und analysiert die Preisbewegung über höhere Timeframes (H4), mittlere Timeframes (H1) und niedrigere Timeframes (M30), um allgemein Markt-Bias und -stimmung zu ermitteln. Auf der Grundlage der berechneten Stimmungswerte, die die Bedingungen von „Strong Bullish“ bis „Strong Bearish“, „Risk-On“ bis „Risk-Off“ und Neutral umfassen, wählt der EA dynamisch die am besten geeignete SMC-Strategie aus und priorisiert sie, um sicherzustellen, dass die Handelsentscheidungen mit den vorherrschenden Marktbedingungen übereinstimmen, anstatt einen Einheitsansatz anzuwenden.

Neutrale Marktstimmung + Orderblock-Strategie

Bei neutralen Marktbedingungen – gekennzeichnet durch eine Preiskonsolidierung in der Nähe der gleitenden Durchschnitte und das Fehlen einer eindeutigen Ausrichtung auf einen höheren Zeitrahmen – aktiviert das System die Strategie der Orderblöcke (OB) als primäre Handelsmethode. Eine neutrale Stimmung deutet in der Regel auf Märkte hin, die sich in einer Bandbreite bewegen, in der die Kurse zwischen etablierten Unterstützungs- und Widerstandsniveaus oszillieren, ohne dass sie eine starke Richtungsdynamik aufweisen. In diesem Umfeld sind Orderblöcke äußerst effektiv, da sie Bereiche identifizieren, in denen zuvor institutionelle Aufträge aufgegeben wurden, wodurch natürliche Reaktionszonen entstehen. Der EA sucht speziell nach Aufwärts-OBs (Abwärtskerze gefolgt von einer starken Aufwärtskerze) und Abwärts-OBs (Aufwärtskerze gefolgt von einer starken Abwärtskerze), die ein signifikantes Ungleichgewicht im Orderflow aufweisen. Wenn der Kurs zu diesen identifizierten OB-Zonen zurückgeht, führt das System Handelsgeschäfte in der Erwartung einer Rückkehr zum Mittelwert aus und macht sich dabei die Trends des Marktes zunutze, während Konsolidierungsphasen frühere Auftragsakkumulationsbereiche zu respektieren haben.

Markttrend-Sentiment (steigend/fallend) + Break-of-Structure-Strategie

Wenn das System eine stark steigende oder fallende Stimmung erkennt – was auf klare Richtungstrends hinweist, die über mehrere Zeitrahmen hinweg bestätigt werden –, priorisiert es die Strategie der Strukturbrüche (BoS), um von der Fortsetzung des Momentums zu profitieren. In Märkten, die durch höhere Hochs und höhere Tiefs (steigend) oder niedrigere Hochs und niedrigere Tiefs (fallend) gekennzeichnet sind, identifiziert BoS wichtige Umkehrpunkte, an denen die Marktstruktur durchbrochen wurde, was eine potenzielle Beschleunigung in die vorherrschende Richtung signalisiert. Der EA achtet darauf, ob der Kurs bei Aufwärtstrends über die jüngsten hohen Umkehrpunkte oder bei Abwärtstrends unter die jüngsten tiefen Umkehrpunkte ausbricht, und interpretiert diese Ausbrüche als Liquiditätsläufe, die oft nachhaltigen Richtungsbewegungen vorausgehen. Diese Strategie passt perfekt zu Trendbedingungen, da sie sich darauf konzentriert, nach einer strukturellen Bestätigung in die Richtung des etablierten Trends einzusteigen und gegenläufige Trades zu vermeiden, die bei starken Richtungswechseln eine geringere Erfolgswahrscheinlichkeit haben würden.

Risk-On/Risk-Off-Sentiment + Fair-Value-Gaps-Strategie

In Marktphasen, die von Stimmungen des Risk-On oder Risk-Off geprägt sind – gekennzeichnet durch Ausbrüche aus etablierten Handelsspannen in Verbindung mit einem Bias in höheren Zeitrahmen –, wendet das System die Strategie des Fair-Value-Gaps (FVG) an. Diese Bedingungen treten typischerweise auf, wenn sich der Kurs konsolidiert hat, aber plötzlich eine Impulsausweitung erfährt, wodurch Lücken zwischen aufeinanderfolgenden Kerzen entstehen, in denen nur ein minimaler Handel stattfindet. Der EA identifiziert diese Ungleichgewichtszonen, in denen Kauf- oder Verkaufsdruck zu erheblichen Preislücken geführt hat, und geht davon aus, dass der Preis innerhalb dieser Lücken schließlich zum „fairen Wert“ zurückkehren wird. Das System handelt speziell auf dem 50 %-Gleichgewichtsniveau dieser Lücken und bietet optimale Risiko-Rendite-Einstiegspunkte während volatiler Ausbruchszeiten. Dieser Ansatz macht sich den Trend des Marktes zunutze, Preisineffizienzen zu füllen, während er gleichzeitig die allgemeine Tendenz der Richtung respektiert, was ihn ideal für Übergangsmarktphasen macht, in denen sich eine Dynamik entwickelt, der Trend jedoch noch nicht vollständig etabliert ist.

Die ersten Schritte

//+------------------------------------------------------------------+
//|                                                     SMC_Sent.mq5 |
//|                        GIT under Copyright 2025, MetaQuotes Ltd. |
//|                     https://www.mql5.com/en/users/johnhlomohang/ |
//+------------------------------------------------------------------+
#property copyright "GIT under Copyright 2025, MetaQuotes Ltd."
#property link      "https://www.mql5.com/en/users/johnhlomohang/"
#property version   "2.00"
#property description "Intelligent SMC EA with Market Sentiment-Based Strategy Switching"
#property copyright "Based on MARKSENT and SMCALL"

#include <Trade/Trade.mqh>
#include <Trade/PositionInfo.mqh>
#include <Arrays/ArrayObj.mqh>

// Market Sentiment Component (from MARKSENT)
input group "=== Market Sentiment Settings ==="
input ENUM_TIMEFRAMES HigherTF = PERIOD_H4;
input ENUM_TIMEFRAMES LowerTF1 = PERIOD_H1;
input ENUM_TIMEFRAMES LowerTF2 = PERIOD_M30;
input int MAPeriod = 200;
input int SwingLookback = 5;
input double ATRThreshold = 0.002;

input group "=== Trading Settings ==="
input double LotSize = 0.02;
input double StopLoss = 500;
input double TakeProfit = 1500;
input long MagicNumber = 76543;
input bool EnableTrading = true;
input bool DrawAllObjects = true; // Draw all trading objects

input group "=== Strategy Selection ==="
input bool UseSentimentFilter = true; // Use sentiment to choose strategies
input bool AllowBOS = true;           // Allow Break of Structure strategy
input bool AllowOB = true;            // Allow Order Blocks strategy  
input bool AllowFVG = true;           // Allow Fair Value Gaps strategy

input group "=== Visual Settings ==="
input int PanelCorner = 0;           // Top-left corner
input int PanelX = 10;
input int PanelY = 10;
input string FontFace = "Arial";
input int FontSize = 10;

// Color scheme based on market sentiment
input color BullishColor = clrLimeGreen;
input color BearishColor = clrRed;
input color RiskOnColor = clrDodgerBlue;
input color RiskOffColor = clrOrangeRed;
input color NeutralColor = clrGold;

// Strategy drawing colors
input color OB_BullColor = clrLime;
input color OB_BearColor = clrRed;
input color FVG_BullColor = clrPaleGreen;
input color FVG_BearColor = clrMistyRose;
input color BOS_BullColor = clrDodgerBlue;
input color BOS_BearColor = clrTomato;

// Cleanup settings
input bool RemoveObjectsAfterTradeClose = true;
input int RemoveObjectsAfterBars = 10; // Remove objects after X bars

// Global variables
CTrade trade;
CPositionInfo poss;

// Market Sentiment Handles
int higherTFHandle, lowerTF1Handle, lowerTF2Handle;
double higherTFMA[], lowerTF1MA[], lowerTF2MA[];
datetime lastSentimentUpdate = 0;
int currentSentiment = 0; // -2:RiskOff, -1:Bearish, 0:Neutral, 1:Bullish, 2:RiskOn
string currentSentimentText = "Neutral";

// SMC Trading Variables
datetime lastBarTime = 0;
double Bid, Ask;
string currentStrategy = "ALL";

Wir beginnen mit der Einbindung der erforderlichen MQL5-Bibliotheken für die Auftragsausführung, die Positionsinformationen und die Array-Verwaltung, die die Grundlage sowohl für die Handelsoperationen als auch für die vom EA benötigte Datenspeicherung bilden. Der erste Abschnitt definiert alle Eingaben für die Komponente des Market-Sentiments, die Daten über mehrere Zeitrahmen (H4, H1, M30) liest und verarbeitet und dabei Tools wie einen gleitenden 200-Perioden-Durchschnitt, Swing-Lookbacks und ATR-Schwellenwerte verwendet. Diese Parameter gehören zur nutzerdefinierten Sentiment-Engine (MARKSENT) und ermöglichen es dem EA, das Marktumfeld in Zustände wie „bullish“, „bearish“, „risk-on“, „risk-off“ oder „neutral“ zu klassifizieren. Durch die gemeinsame Analyse dieser verschiedenen Zeitrahmen entwickelt der EA ein solides Verständnis der aktuellen Marktrichtung und der Volatilitätsmerkmale.

Im nächsten Abschnitt definieren wir die Handelseinstellungen und die Strategieauswahl, die dem EA Flexibilität in seiner Arbeitsweise verleihen. Eingaben wie Losgröße, Stop-Loss, Take-Profit, magische Zahl und Kontrolle für die Darstellung von Objekten bestimmen, wie Aufträge ausgeführt und visualisiert werden. Noch wichtiger ist, dass der Block der Strategieauswahl es dem Nutzer ermöglicht, Reaktionen auf Marktstimmungen zu aktivieren oder zu deaktivieren und selektiv die Logik von BoS, OB und FVG zu aktivieren. Das bedeutet, dass der EA so konfiguriert werden kann, dass er ausschließlich auf der Grundlage der Stimmung handelt, allein auf der Grundlage von SMC-Mustern oder als hybrides Modell arbeitet, das je nach dem vom Indikator erkannten Stimmungszustand intelligent zwischen den Strategien wechselt. In Kombination mit anpassbaren visuellen Parametern gewährleistet dieser Abschnitt sowohl Funktionalität als auch Klarheit auf dem Chart.

Anschließend richten wir alle globalen Variablen und Puffer ein, die für die Echtzeitberechnungen benötigt werden, einschließlich der Handles für MAs mit höherem und niedrigerem Zeitrahmen, der Verfolgung des Stimmungszustands und der SMC-Strategieaktivität. Variablen wie currentSentiment, currentSentimentText und currentStrategy dienen als Entscheidungsanker: Sie speichern die aktuelle Marktstimmung und die aktive Strategie, die auf das nächste Signal angewendet werden soll. Der EA aktualisiert fortlaufend die Bid/Ask-Kurse, identifiziert neue Balken und bestimmt, wann alte SMC-Objekte aus dem Chart entfernt werden, um eine effektive Visualisierung zu gewährleisten. Zusammen bilden diese globalen Komponenten das Kerngerüst, das es dem EA ermöglicht, die Marktstimmung mit Smart-Money-Konzepten zu verbinden und so ein adaptives Handelssystem zu schaffen, das seine Logik an die Entwicklung des Marktes anpasst.

// Trade information structure
struct TradeInfo
{
   long ticket;
   string symbol;
   datetime openTime;
   double openPrice;
   ENUM_ORDER_TYPE type;
   string strategy;
   long magic;
   
   TradeInfo() : ticket(-1), symbol(""), openTime(0), openPrice(0), type(WRONG_VALUE), strategy(""), magic(0) {}
};

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
{
    trade.SetExpertMagicNumber(MagicNumber);
    indicatorName = "IntelligentSMC_" + IntegerToString(ChartID());
    
    // Initialize market sentiment indicators
    higherTFHandle = iMA(_Symbol, HigherTF, MAPeriod, 0, MODE_EMA, PRICE_CLOSE);
    lowerTF1Handle = iMA(_Symbol, LowerTF1, MAPeriod, 0, MODE_EMA, PRICE_CLOSE);
    lowerTF2Handle = iMA(_Symbol, LowerTF2, MAPeriod, 0, MODE_EMA, PRICE_CLOSE);
    
    ArraySetAsSeries(higherTFMA, true);
    ArraySetAsSeries(lowerTF1MA, true);
    ArraySetAsSeries(lowerTF2MA, true);
    
    // Initialize arrays
    detectedFVGs = new CArrayObj();
    detectedBOSZones = new CArrayObj();
    tradedOBs = new CArrayObj();
    activeTrades = new CArrayObj();
    
    CreateControlPanel();
    
    Print("Intelligent SMC EA Started - Strategy Switching & Clean Drawing Enabled");
    return(INIT_SUCCEEDED);
}

//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
    IndicatorRelease(higherTFHandle);
    IndicatorRelease(lowerTF1Handle);
    IndicatorRelease(lowerTF2Handle);
    
    // Clean up all objects
    CleanupAllObjects();
    
    if(currentOB != NULL) 
    {
        delete currentOB;
        currentOB = NULL;
    }
    
    // Clean up FVGs
    if(detectedFVGs != NULL)
    {
        for(int i = detectedFVGs.Total()-1; i >= 0; i--)
        {
            CFVG* fvg = (CFVG*)detectedFVGs.At(i);
            if(fvg != NULL) delete fvg;
        }
        delete detectedFVGs;
    }
    
    // Clean up BOS zones
    if(detectedBOSZones != NULL)
    {
        for(int i = detectedBOSZones.Total()-1; i >= 0; i--)
        {
            CBOSZone* bos = (CBOSZone*)detectedBOSZones.At(i);
            if(bos != NULL) delete bos;
        }
        delete detectedBOSZones;
    }
    
    // Clean up traded OBs
    if(tradedOBs != NULL)
    {
        for(int i = tradedOBs.Total()-1; i >= 0; i--)
        {
            COrderBlock* ob = (COrderBlock*)tradedOBs.At(i);
            if(ob != NULL) delete ob;
        }
        delete tradedOBs;
    }
    
    // Clean up active trades
    if(activeTrades != NULL)
    {
        delete activeTrades;
    }
    
    ObjectsDeleteAll(0, indicatorName);
    Comment("");
}

//+------------------------------------------------------------------+
//| Cleanup all graphical objects                                    |
//+------------------------------------------------------------------+
void CleanupAllObjects()
{
    // Clean up old objects
    string prefix = "";
    int total = ObjectsTotal(0);
    
    for(int i = total-1; i >= 0; i--)
    {
        string name = ObjectName(0, i);
        if(StringFind(name, "OB_", 0) == 0 ||
           StringFind(name, "FVG_", 0) == 0 ||
           StringFind(name, "BOS_", 0) == 0 ||
           StringFind(name, "Trade_", 0) == 0)
        {
            ObjectDelete(0, name);
        }
    }
}

Dieser Abschnitt definiert die Struktur TradeInfo, die alle wichtigen Informationen über die vom EA eröffneten Handelsgeschäfte speichert – Ticket, Symbol, Einstiegszeit, Preis, Auftragsart, verwendete Strategie und magische Nummer. Der Standardkonstruktor initialisiert jedes Feld auf einen sicheren „leeren“ Zustand, um sicherzustellen, dass keine uninitialisierten Werte Logikfehler verursachen, wenn der EA Handelsdaten verarbeitet oder speichert. Diese Struktur ist besonders wichtig für ein adaptives Multi-Strategie-System wie dieses, da sie es dem EA ermöglicht, nachzuvollziehen, welche Strategie (OB, FVG oder BoS) jeden Handel ausgelöst hat, was Funktionen wie Performance-Tracking, Bereinigung oder strategiespezifisches Handelsmanagement ermöglicht.

Die Funktionen OnInit() und OnDeinit() behandeln den Aufbau und Abbau des gesamten EA. Bei der Initialisierung setzt der EA die magische Zahl, bereitet eindeutige Indikatorennamen vor und erstellt alle gleitenden Durchschnittswerte, die von der Market-Sentiment-Engine über mehrere Zeitrahmen hinweg verwendet werden. Sie konfiguriert auch Arrays als Zeitreihen und weist Objektcontainer für erkannte SMC-Strukturen – FVGs, BoS-Zonen und gehandelte OBs – sowie eine aktive Handelsverfolgung zu. Es wird ein Kontrollpanel für die Überwachung auf dem Chart erstellt, und der EA meldet, dass der dynamische SMC und die Logik für den Strategiewechsel bereit sind. Umgekehrt sorgt OnDeinit() für ein sauberes Herunterfahren, indem es die Indikator-Handles freigibt, alle dynamisch zugewiesenen SMC-Objekte löscht, die Handels-Arrays leert und alle OB/FVG/BoS-Zeichnungen aus dem Chart entfernt. Die Funktion CleanupAllObjects() sorgt für eine aufgeräumte Chart-Umgebung, indem sie systematisch alle grafischen Objekte löscht, die den SMC-Namenskonventionen entsprechen. Zusammen sorgen diese Routinen dafür, dass der EA sauber initialisiert wird, den Speicher verantwortungsvoll verwaltet und beim Entfernen keine Unordnung hinterlässt.

// Market Sentiment Calculation Component
int CalculateMarketSentiment()
{
    if(TimeCurrent() - lastSentimentUpdate < 5) 
        return currentSentiment;
    
    lastSentimentUpdate = TimeCurrent();
    
    // Get MA values from multiple timeframes
    CopyBuffer(higherTFHandle, 0, 0, 3, higherTFMA);
    CopyBuffer(lowerTF1Handle, 0, 0, 3, lowerTF1MA);
    CopyBuffer(lowerTF2Handle, 0, 0, 3, lowerTF2MA);
    
    double higherTFPrice = iClose(_Symbol, HigherTF, 0);
    double lowerTF1Price = iClose(_Symbol, LowerTF1, 0);
    double lowerTF2Price = iClose(_Symbol, LowerTF2, 0);
    
    // Calculate biases across timeframes
    int higherTFBias = GetHigherTFBias(higherTFPrice, higherTFMA[0]);
    bool lowerTF1Bullish = IsBullishStructure(LowerTF1, SwingLookback);
    bool lowerTF1Bearish = IsBearishStructure(LowerTF1, SwingLookback);
    bool lowerTF2Bullish = IsBullishStructure(LowerTF2, SwingLookback);
    bool lowerTF2Bearish = IsBearishStructure(LowerTF2, SwingLookback);
    bool lowerTF1Breakout = HasBreakout(LowerTF1, SwingLookback, higherTFBias);
    bool lowerTF2Breakout = HasBreakout(LowerTF2, SwingLookback, higherTFBias);
    
    // Determine final sentiment based on multi-timeframe analysis
    currentSentiment = DetermineSentiment(higherTFBias, 
        lowerTF1Bullish, lowerTF1Bearish, lowerTF1Breakout,
        lowerTF2Bullish, lowerTF2Bearish, lowerTF2Breakout);
    
    // Update sentiment text for display
    switch(currentSentiment)
    {
        case 1: currentSentimentText = "Bullish"; break;
        case -1: currentSentimentText = "Bearish"; break;
        case 2: currentSentimentText = "Risk-On"; break;
        case -2: currentSentimentText = "Risk-Off"; break;
        default: currentSentimentText = "Neutral"; break;
    }
    
    return currentSentiment;
}

// Strategy Selection Logic based on Market Sentiment
string SelectTradingStrategy()
{
    if(!UseSentimentFilter) 
    {
        currentStrategy = "ALL"; // Use all strategies if no filter
        return currentStrategy;
    }
    
    int sentiment = CalculateMarketSentiment();
    
    // Strategy assignment based on market conditions
    switch(sentiment)
    {
        case 1:  // Strong Bullish
        case -1: // Strong Bearish
            currentStrategy = "BOS"; // Use Break of Structure in strong trends
            break;
            
        case 2:  // Risk-On (Bullish with breakout)
        case -2: // Risk-Off (Bearish with breakout)  
            currentStrategy = "FVG"; // Use Fair Value Gaps during breakouts
            break;
            
        case 0:  // Neutral/Ranging
        default:
            currentStrategy = "OB"; // Use Order Blocks in ranging markets
            break;
    }
    
    return currentStrategy;
}

Hier berechnen wir die Marktstimmung, indem wir gleitende Durchschnitte mit mehreren Zeitrahmen, die strukturelle Swing-Analyse und die Erkennung von Ausbrüchen zu einem einheitlichen Bias-Score zusammenfassen. Die Funktion beginnt mit einer Begrenzung der Neuberechnungen auf alle 5 Sekunden, um die Effizienz zu erhöhen, und ruft dann die MA-Werte aus den höheren und niedrigeren Zeitrahmen-Handles ab. Es untersucht den Preis relativ zu den MAs, um die Richtung im höheren Zeitrahmen zu bestimmen, während es gleichzeitig die Strukturen im unteren Zeitrahmen mit Funktionen wie IsBullishStructure, IsBearishStructure und HasBreakout analysiert. Diese Analyseebenen – Trend, Struktur und Ausbrüche – werden an DetermineSentiment weitergegeben, das eine Stimmungseinstufung von stark „bullish“ (1) bis „risk-off“ (-2) liefert. Sobald die numerische Stimmung ermittelt ist, weist der EA eine beschreibende Bezeichnung („Bullish“, „Bearish“ usw.) zu, die auf dem Panel angezeigt wird.

Die Logik für die Strategieauswahl verwendet dann diesen Sentiment-Output, um dynamisch zu entscheiden, welche SMC-Methode der EA handeln soll. Wenn die Stimmungsfilterung deaktiviert ist, aktiviert der EA einfach alle Strategien. Wenn sie aber aktiv ist, passt der EA sich intelligent an: Starke Aufwärts- oder Abwärtsbewegungen aktivieren den BoS-Fortsetzungshandel, Ausbruchsbedingungen mit hohem oder niedrigem Risiko bevorzugen den FVG-Ungleichgewichtshandel, und neutrale oder schwankende Märkte begünstigen Orderblock-Umkehrungen. Auf diese Weise entsteht ein adaptives System, bei dem der EA automatisch zwischen BoS-, FVG- und OB-Strategien auf der Grundlage der Echtzeitstimmung und des Preisverhaltens wechselt und so die Entscheidungsfindung eines professionellen Händlers nachahmt, der seine Methoden je nach Marktlage anpasst.

// Execute Trade with Sentiment Filtering
bool ExecuteTradeWithFilter(ENUM_ORDER_TYPE type, string strategy)
{
    if(!EnableTrading) return false;
    
    // Check if selected strategy is allowed
    if((strategy == "BOS" && !AllowBOS) || 
       (strategy == "OB" && !AllowOB) ||
       (strategy == "FVG" && !AllowFVG))
        return false;
    
    // Check sentiment alignment before executing trade
    int sentiment = CalculateMarketSentiment();
    bool sentimentAligned = false;
    
    // Bullish trades aligned with bullish sentiment
    if((type == ORDER_TYPE_BUY && (sentiment == 1 || sentiment == 2)) ||
       // Bearish trades aligned with bearish sentiment
       (type == ORDER_TYPE_SELL && (sentiment == -1 || sentiment == -2)))
        sentimentAligned = true;
    
    // Allow neutral sentiment trades with caution
    if(sentiment == 0) sentimentAligned = true;
    
    if(!sentimentAligned)
    {
        Print("Trade rejected: Not aligned with market sentiment (", currentSentimentText, ")");
        return false;
    }
    
    // Execute the trade with strategy context
    double point = SymbolInfoDouble(_Symbol, SYMBOL_POINT);
    double price = (type == ORDER_TYPE_BUY) ? Ask : Bid;
    double sl = (type == ORDER_TYPE_BUY) ? price - StopLoss * point : price + StopLoss * point;
    double tp = (type == ORDER_TYPE_BUY) ? price + TakeProfit * point : price - TakeProfit * point;
    
    sl = NormalizeDouble(sl, _Digits);
    tp = NormalizeDouble(tp, _Digits);
    
    trade.SetExpertMagicNumber(MagicNumber);
    bool result = trade.PositionOpen(_Symbol, type, LotSize, price, sl, tp, 
       "SMC_" + strategy + "_Sent:" + currentSentimentText);
    
    if(result)
    {
        long ticket = trade.ResultOrder();
        Print("Trade executed: ", EnumToString(type), 
              " | Strategy: ", strategy, 
              " | Sentiment: ", currentSentimentText,
              " | Price: ", DoubleToString(price, _Digits),
              " | Ticket: ", ticket);
        
        return true;
    }
    
    return false;
}

Diese Funktion stellt sicher, dass jeder vom EA ausgeführte Handel sowohl mit der Strategie als auch mit der Stimmung übereinstimmt, wodurch eine Sicherheitsebene geschaffen wird, die verhindert, dass Handelsgeschäfte entgegen den vorherrschenden Marktbedingungen getätigt werden. Zunächst wird geprüft, ob der Handel aktiviert ist und ob die gewählte SMC-Strategie (BoS, OB oder FVG) derzeit zulässig ist. Anschließend wird die aktuelle Marktstimmung abgefragt und überprüft, ob die beabsichtigte Auftragsrichtung mit dieser Stimmung übereinstimmt. So sind beispielsweise Kaufgeschäfte nur bei einer steigenden oder risikofreudigen Stimmung zulässig, während Verkaufsgeschäfte eine fallende oder risikoarme Stimmung erfordern.

Neutrale Märkte erlauben den Handel, allerdings mit erhöhter Vorsicht. Wenn das Sentiment und die Strategie übereinstimmen, berechnet die Funktion normalisierte SL- und TP-Niveaus, weist die magische Zahl des EAs zu und eröffnet eine neue Position mit einem Kommentar, der die verwendete Strategie und das Sentiment beschreibt. Erfolgreiche Handelsgeschäfte werden mit detaillierten Informationen protokolliert, sodass Transparenz und vollständige Nachvollziehbarkeit gewährleistet sind, wie das Sentiment die Ausführung beeinflusst hat.

// Market Sentiment Helper Functions
int GetHigherTFBias(double price, double maValue)
{
    double deviation = MathAbs(price - maValue) / maValue;
    if(price > maValue && deviation > ATRThreshold) return 1;   // Bullish bias
    else if(price < maValue && deviation > ATRThreshold) return -1; // Bearish bias
    else return 0; // Neutral/no bias
}

bool IsBullishStructure(ENUM_TIMEFRAMES tf, int lookback)
{
    int swingHighIndex = iHighest(_Symbol, tf, MODE_HIGH, lookback*2, 1);
    int swingLowIndex = iLowest(_Symbol, tf, MODE_LOW, lookback*2, 1);
    if(swingHighIndex == -1 || swingLowIndex == -1) return false;
    
    // Bullish structure: Higher highs AND higher lows
    return (iHigh(_Symbol, tf, swingHighIndex) > iHigh(_Symbol, tf, swingHighIndex + lookback) &&
            iLow(_Symbol, tf, swingLowIndex) > iLow(_Symbol, tf, swingLowIndex + lookback));
}

bool IsBearishStructure(ENUM_TIMEFRAMES tf, int lookback)
{
    int swingHighIndex = iHighest(_Symbol, tf, MODE_HIGH, lookback*2, 1);
    int swingLowIndex = iLowest(_Symbol, tf, MODE_LOW, lookback*2, 1);
    if(swingHighIndex == -1 || swingLowIndex == -1) return false;
    
    // Bearish structure: Lower highs AND lower lows
    return (iHigh(_Symbol, tf, swingHighIndex) < iHigh(_Symbol, tf, swingHighIndex + lookback) &&
            iLow(_Symbol, tf, swingLowIndex) < iLow(_Symbol, tf, swingLowIndex + lookback));
}

bool HasBreakout(ENUM_TIMEFRAMES tf, int lookback, int higherTFBias)
{
    int swingHighIndex = iHighest(_Symbol, tf, MODE_HIGH, lookback, 1);
    int swingLowIndex = iLowest(_Symbol, tf, MODE_LOW, lookback, 1);
    if(swingHighIndex == -1 || swingLowIndex == -1) return false;
    
    double swingHigh = iHigh(_Symbol, tf, swingHighIndex);
    double swingLow = iLow(_Symbol, tf, swingLowIndex);
    double price = iClose(_Symbol, tf, 0);
    
    // Breakout in direction of higher timeframe bias
    if(higherTFBias == 1) return (price > swingHigh); // Bullish breakout
    if(higherTFBias == -1) return (price < swingLow); // Bearish breakout
    
    return false;
}

Diese Hilfsfunktionen bilden das analytische Rückgrat der Sentiment-Engine des EA, indem sie das Kursverhalten über mehrere Zeitrahmen hinweg auswerten und in Richtungsvorgaben umwandeln. GetHigherTFBias() vergleicht den aktuellen Kurs mit dem gleitenden Durchschnitt des höheren Zeitrahmens und verwendet sowohl die Richtung als auch die Größe der Abweichung, um festzustellen, ob der Markt nach oben oder nach unten tendiert oder keine eindeutige Bewegung zeigt. Die Funktionen IsBullishStructure() und IsBearishStructure() untersuchen dann die Marktstruktur, indem sie die jüngsten Hochs und Tiefs der Schwankungen vergleichen: Formationen mit höheren Hochs und höheren Tiefs bestätigen eine Aufwärts-Struktur, während Muster mit niedrigeren Hochs und niedrigeren Tiefs eine Abwärts-Struktur bestätigen. Diese Funktionen helfen dem EA, echte Strukturverschiebungen zu erkennen, anstatt auf Rauschen zu reagieren.

Die Funktion HasBreakout() fügt eine dynamische Ebene hinzu, indem sie prüft, ob der Preis aus den Niveaus der letzten Umkehrpunkte in Übereinstimmung mit dem Trend des höheren Zeitrahmens ausgebrochen ist. In einem steigenden Umfeld beispielsweise hält der EA Ausbrüche nur dann für sinnvoll, wenn der Kurs die jüngsten hohen Umkehrpunkte überschreitet, was auf eine Fortsetzung des Momentums hindeutet. Wenn diese drei Komponenten – Trendverzerrung, strukturelle Richtung und Ausbruchsbestätigung – kombiniert werden, ergeben sie eine robuste Multi-Timeframe-Stimmungsmessung, die der EA verwendet, um die Strategieauswahl zu steuern, Handelsgeschäfte zu filtern und sich intelligent an veränderte Marktbedingungen anzupassen.

int DetermineSentiment(int higherTFBias, 
                      bool tf1Bullish, bool tf1Bearish, bool tf1Breakout,
                      bool tf2Bullish, bool tf2Bearish, bool tf2Breakout)
{
    // Strong Bullish: Higher TF bullish + both lower TFs bullish
    if(higherTFBias == 1 && tf1Bullish && tf2Bullish) return 1;
    
    // Strong Bearish: Higher TF bearish + both lower TFs bearish
    if(higherTFBias == -1 && tf1Bearish && tf2Bearish) return -1;
    
    // Risk-On: Higher TF bullish + breakout on either lower TF
    if(higherTFBias == 1 && (tf1Breakout || tf2Breakout)) return 2;
    
    // Risk-Off: Higher TF bearish + breakout on either lower TF
    if(higherTFBias == -1 && (tf1Breakout || tf2Breakout)) return -2;
    
    // Neutral: No clear bias or conflicting signals
    return 0;
}

// Main Execution Flow with Sentiment-Strategy Integration
void OnTick()
{
    Bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);
    Ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
    
    if(!IsNewBar()) return;
    
    // Clean up expired objects
    CleanupExpiredObjects();
    
    // Calculate current market sentiment
    CalculateMarketSentiment();
    
    // Select strategy based on sentiment
    string selectedStrategy = SelectTradingStrategy();
    
    // Execute selected strategies based on sentiment
    if(selectedStrategy == "ALL" || selectedStrategy == "BOS")
        DetectAndTradeBOS(); // Break of Structure strategy
        
    if(selectedStrategy == "ALL" || selectedStrategy == "OB")
        DetectAndTradeOrderBlocks(); // Order Blocks strategy
        
    if(selectedStrategy == "ALL" || selectedStrategy == "FVG")
        DetectAndTradeFVGs(); // Fair Value Gaps strategy
    
    // Display current status with sentiment info
    DisplayStatus();
}

// Display status with sentiment information
void DisplayStatus()
{
    int fvgCount = (detectedFVGs != NULL) ? detectedFVGs.Total() : 0;
    int bosCount = (detectedBOSZones != NULL) ? detectedBOSZones.Total() : 0;
    int obCount = (tradedOBs != NULL) ? tradedOBs.Total() : 0;
    if(currentOB != NULL) obCount++;
    
    string status = "SMC Strategy with Market Sentiment\n" +
                   "══════════════════════════════════\n" +
                   "Market Sentiment: " + currentSentimentText + "\n" +
                   "Active Strategy: " + currentStrategy + "\n" +
                   "══════════════════════════════════\n" +
                   "Patterns Detected:\n" +
                   "• Order Blocks: " + IntegerToString(obCount) + "\n" +
                   "• FVGs: " + IntegerToString(fvgCount) + "\n" +
                   "• BOS Zones: " + IntegerToString(bosCount) + "\n" +
                   "══════════════════════════════════\n" +
                   "Trading Status: " + (EnableTrading ? "ACTIVE" : "PAUSED");
    
    Comment(status);
}

Die Funktion DetermineSentiment() fungiert als letzte Entscheidungsebene der Sentiment-Engine, indem sie die Trendrichtung im höheren Zeitrahmen mit der Struktur im niedrigeren Zeitrahmen und der Ausbruchsbestätigung verbindet. Es kategorisiert die Stimmung in fünf verschiedene Zustände – stark steigend, stark fallend, risikofreudig, risikoscheu und neutral –, je nachdem, wie gut die Zeitrahmen zueinanderpassen. Wenn beide unteren Zeitrahmen mit dem Trend des oberen Zeitrahmens übereinstimmen, wird die Stimmung als stark in diese Richtung markiert. Wenn nur das Ausbruchsmomentum mit dem höheren Zeitrahmen übereinstimmt, kommt es zu einem Umfeld von Risk-on oder Risk-off. Alle widersprüchlichen oder unklaren Bedingungen werden auf neutral gesetzt, damit der EA keine aggressiven oder falsch ausgerichteten Entscheidungen treffen kann.

Die Funktion OnTick() orchestriert den Hauptausführungsworkflow des EA, indem sie die Marktstimmung mit der Strategieauswahl und der Handelsausführung verbindet. Bei jedem neuen Balken führt der EA eine Objektbereinigung durch, berechnet das Sentiment neu und wählt die am besten geeignete Strategie – BoS, OB, FVG oder alle – auf der Grundlage des aktuellen Sentiment-Status. Es aktiviert dann die entsprechenden Erkennungs- und Handelsmodule, sodass das System sein Verhalten in Echtzeit an die Marktbedingungen anpassen kann. Auf diese Weise entsteht eine Maschine, die sich nicht auf eine einzige Handelstechnik verlässt, sondern auf intelligente Weise die Strategien wechselt, je nachdem, ob sich der Markt im Trend befindet, sich konsolidiert oder ausbricht.

Schließlich erhöht die Funktion DisplayStatus() die Transparenz, indem sie dem Händler eine strukturierte Echtzeit-Zusammenfassung des internen Zustands des EA anzeigt, einschließlich der erkannten SMC-Muster, des aktuellen Stimmungsniveaus, der aktiven Strategie und ob der Handel aktiviert ist. Diese visuelle Rückmeldung stellt sicher, dass der Nutzer klar versteht, warum der EA bestimmte Entscheidungen trifft, was Vertrauen schafft und gleichzeitig die Überwachung und Fehlerbehebung des Systems erleichtert.

Backtest-Ergebnisse

Das folgende Backtesting wurde auf dem H1-Zeitrahmen über ein etwa zweimonatiges Testfenster (01. Oktober 2025 bis 01. Dezember 2025) mit den folgenden Einstellungen durchgeführt:

Hier sehen Sie die Kapitalkurve und die Backtest-Ergebnisse:

Schlussfolgerung

Zusammenfassend kann gesagt werden, dass wir einen intelligenten SMC-Handels-EA entwickelt haben, indem wir drei Kernstrategien des Smart-Money-Concepts – Orderblöcke, Fair-Value-Gaps und Strukturbrüche – mit einer Echtzeit-Multi-Timeframe-Marktstimmungsanalyse integriert haben. Wir haben ein dynamisches System entwickelt, das auf der Grundlage der aktuellen Marktbedingungen automatisch die am besten geeignete Strategie auswählt: Orderblöcke für neutrale/schwankende Märkte, Strukturbruch bei starken Trends und Fair-Value-Gaps für vorübergehende Ausbruchsszenarien. Der EA verfügt über ein umfassendes visuelles Zeichnen mit handelsbasiertem Objektmanagement, bei dem grafische Elemente nur von ihrem Ursprung bis zum Zeitpunkt der Handelsausführung gezeichnet und automatisch bereinigt werden, wenn der Handel geschlossen wird, wodurch ein übersichtliches Chart gewährleistet wird. Wir haben auch den Strukturbruch verbessert, um die Richtung von Strukturbrüchen deutlich anzuzeigen, sodass Marktbewegungen für Händler sofort sichtbar werden.

Zusammenfassend kann gesagt werden, dass diese hochentwickelte EA-Implementierung den Händlern ein kontextbewusstes, adaptives Handelssystem bietet, das die Entscheidungsfindung durch die Anpassung der SMC-Strategien an die Marktbedingungen in Echtzeit erheblich verbessert. Durch die Eliminierung des Rätselratens bei der Strategieauswahl und die Automatisierung der Handelsausführung im richtigen Marktkontext können Händler ihre Disziplin beibehalten und gleichzeitig von hochwahrscheinlichen Konstellationen profitieren. Das umfassende visuelle Feedbacksystem hilft Händlern, die Marktdynamik in Echtzeit zu verstehen, während die automatische Bereinigung eine optimale Übersichtlichkeit der Charts für die laufende Analyse gewährleistet. Dieser integrierte Ansatz steigert die Handelseffizienz und bietet einen pädagogischen Rahmen für das Verständnis, wie sich verschiedene SMC-Strategien unter verschiedenen Marktbedingungen verhalten, was den Händlern letztlich hilft, ein besseres Gespür für den Markt und verbesserte Risikomanagementpraktiken zu entwickeln.