MQL5 ForexSetEA

string forex[] = { "AUDCHF", "AUDJPY", "AUDUSD", "CADCHF", "CHFJPY", "EURAUD",
                   "EURCAD", "EURCHF", "EURGBP", "EURJPY", "EURNZD", "EURUSD",
                   "GBPCHF", "GBPJPY", "GBPUSD", "USDCAD", "USDCHF", "USDJPY" };

string forex[] = { "USDJPY", "GBPUSD", "EURUSD", "EURJPY", "AUDUSD" };

string forex[] = { _Symbol, "USDJPY", "GBPUSD", "-" };

string forex[] = { _Symbol }; // Einzeltests oder Market scanner

//+------------------------------------------------------------------+
//|                                                AV_ForexSetEA.mq5 |
//|                                       Copyright 2022, Anja Vogel |
//|                                        https://www.anjavogel.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2022, Anja Vogel"
#property link      "https://www.anjavogel.com"
#define MAGIC 20221110
#define VERSION "1.03a"
#property version VERSION
//---
#define ForEachPosition(ticket,i)                                    \
   HistorySelect(0,TimeCurrent());                                   \
   ulong ticket=PositionGetTicket(0);                                \
   int po_total=PositionsTotal();                                    \
   for(int i=1;i<=po_total;i++,ticket=PositionGetTicket(i-1))
//---
#include <Trade\Trade.mqh>
#include <Trade\OrderInfo.mqh>
#include <Trade\PositionInfo.mqh>
//---
CTrade        trade;
COrderInfo    order;
CPositionInfo position;
//+------------------------------------------------------------------+
// Einstellungen:
//+------------------------------------------------------------------+
input int ProfitPunkte = 200;
input int StoplossPunkte = 0;
input int useMaxPercent = 100;  // für mehrere EAs: nutze max. Prozent vom Konto
input int reservedEquity = 200; // reserviere 200,- pro zu öffnender Position

// Im Strategietester z.B 1-10 Durchläufe stabilisiert Ergebnisse durch Zufalls-Einstieg:
input int strategietester = 1;

//+------------------------------------------------------------------+
// OnInit()
//+------------------------------------------------------------------+
int OnInit()
{
   // Hauptwährungen
   if (StringFind(_Symbol, "USD", 0) != -1 || StringFind(_Symbol, "EUR", 0) != -1
    || StringFind(_Symbol, "JPY", 0) != -1 || StringFind(_Symbol, "GBP", 0) != -1
    || StringFind(_Symbol, "CHF", 0) != -1)
   {
      MathSrand(GetTickCount());

      //if (MQLInfoInteger(MQL_TESTER)) useMaxPercent = 100;

      return(INIT_SUCCEEDED);
   }
   return(INIT_FAILED);
}

//+------------------------------------------------------------------+
// OnTick()
//+------------------------------------------------------------------+
void OnTick()
{
   //+------------------------------------------------------------------+
   // Forex-Set Möglichkeiten: 1) "Währungspaar", 2) "-", 3) _Symbol
   //+------------------------------------------------------------------+
   string forex[] = {"AUDCHF", "AUDJPY", "AUDUSD", "CADCHF", "CHFJPY",
                     "EURAUD", "EURCHF", "EURGBP", "EURJPY",
                     "EURNZD", "EURUSD", "GBPCHF", "GBPJPY", "GBPUSD",
                     "USDCAD", "USDCHF", "USDJPY" };
   //+------------------------------------------------------------------+
   //string forex[] = { "USDJPY", "GBPUSD", "EURUSD", "EURJPY", "AUDUSD" };
   //+------------------------------------------------------------------+
   //string forex[] = { "USDJPY", "GBPUSD", "-" }; // , _Symbol
   //+------------------------------------------------------------------+

   //+------------------------------------------------------------------+
   // Verwende alternativ dies für Einzeltests oder den "Market scanner":
   //+------------------------------------------------------------------+
   //string forex[] = { _Symbol };
   //+------------------------------------------------------------------+


   // Die erlaubten Positionen "max" auf die Währungspaare "symbols" aufteilen
   int symbols = 0;
   for (int i=0; i<ArraySize(forex); i++) {
      if (StringLen(forex[i]) != 6) continue; // 6 Zeichen
      symbols++;
   }

   // Konto: max erlaubte Positionen / Equity Stop
   double Balance = AccountInfoDouble(ACCOUNT_BALANCE);
   double Equity  = AccountInfoDouble(ACCOUNT_EQUITY);

   const int maxAccount = (int)MathFloor(MathMin(Balance, Equity) / reservedEquity);
   int max = (int)MathFloor(MathMin(Balance, Equity)/100*useMaxPercent / reservedEquity);
   if (max < 1) max = 1;

   int maxOnEachSymbol = (int)MathRound(max/symbols);
   if (maxOnEachSymbol < 1) maxOnEachSymbol = 1;

   // EA-Positions
   calculatePositions(); // alle Positionen berechnen für Ausgabe
   int openPositionsEA = openPositions;

   string currentName = "";
   int currentPos = 0;

   // Infobox
   string forexInfo1 = "";
   string forexInfo2 = "";
   string forexInfo3 = "";

   for (int i=0; i<ArraySize(forex); i++) {
      if (StringLen(forex[i]) != 6) continue; // 6 Zeichen

      if (currentName != forex[i]) {
         currentName = forex[i];

         calculatePositions(currentName);
         currentPos = openPositions;

         // Infobox
         if (StringLen(forexInfo1) < 42) forexInfo1 += (string)currentName + " ";
         else if (StringLen(forexInfo2) < 42) forexInfo2 += (string)currentName + " ";
         else forexInfo3 += (string)currentName + " ";
      }

      // Sind mehr Positionen in dem Paar erlaubt? Symbol/EA/Account
      if (openPositions < maxOnEachSymbol && openPositionsEA < max && PositionsTotal() < maxAccount) {

         // ATR-Filter verhindert Einstieg an Extremen
         if (CheckATR(currentName) > 0) {
            if (CheckTrendSwap(currentName) > 0) Comment(currentName + " " + CheckTrendToday(currentName));

            // Wenn es Profit in Buy Richtung, keine offenen Positionen oder Loss bei Sells gibt
            if (openBuyProfit > 0 || currentPos == 0) // || openSellProfit < 0

            // Tag und Monat nach oben, Buy-Swap positiv und Zufall nach oben
            if (CheckTrend(currentName) > 0 && CheckTrendToday(currentName) > 0 && CheckTrendSwap(currentName) > 0)
            {
               OpenBuyOrder(currentName); // Kaufe eine Long-Position
               currentPos++;
               openPositionsEA++;
            }

            // Wenn es Profit in Sell Richtung, keine offenen Positionen oder Loss bei Buys gibt
            if (openSellProfit > 0 || currentPos == 0) //  || openBuyProfit < 0

            // Tag und Monat nach unten, Sell-Swap positiv und Zufall nach unten
            if (CheckTrend(currentName) < 0 && CheckTrendToday(currentName) < 0 && CheckTrendSwap(currentName) < 0)
            {
               OpenSellOrder(currentName); // Kaufe eine Short-Position
               currentPos++;
               openPositionsEA++;
            }
         }
      }
   }

   calculatePositions(); // alle Positionen berechnen für Ausgabe

   string Text[] = {
      "  ",
      //"  Balance:    " + (string)NormalizeDouble(Balance,1),
      //"  Equity:     " + (string)NormalizeDouble(Equity,1),
      "  Open Buy:   " + (string)NormalizeDouble(openBuyProfit,1),
      "  Open Sell:  " + (string)NormalizeDouble(openSellProfit,1),
      "  Open:       " + (string)openPositions + " Pos.",
      " ",
      "  Max Konto:  " + (string)maxAccount + " Pos.",
      "  Max EA:     " + (string)max + " Pos.",
      "  Max Symbol: " + (string)maxOnEachSymbol + " Pos.",
      " ",
      " Forex-Set enthält " + (string)symbols + " Paare:",
      " " + forexInfo1,
      " " + forexInfo2,
      " " + forexInfo3
   };

   ChartWrite("Info", Text, 15, 5);
}


//+------------------------------------------------------------------+
// Einstieg zufällig: kaufen, verkaufen, nichts tun
//+------------------------------------------------------------------+
int CheckTrend(string currentSymbol)
{
   return (MathRand() % 3) - 1;
}

//+------------------------------------------------------------------+
// Filter: Tag und Monat entscheiden erlaubte Trade-Richtung
// Zeitbeschränkung ist hier auch drin
//+------------------------------------------------------------------+
int startNotBefore = 3;

double CheckTrendToday(string currentSymbol)
{
   if (Hour() < startNotBefore) return 0.0; // Zeit begrenzen

   MqlRates PriceInfo[];
   ArraySetAsSeries(PriceInfo,true);

   int Data = CopyRates(currentSymbol,PERIOD_D1,0,3,PriceInfo); // Tag
   double startToday = PriceInfo[0].open;

   Data = CopyRates(currentSymbol,PERIOD_MN1,0,3,PriceInfo); // Monat
   double startMonth = PriceInfo[0].open;

   double currentPrice = PriceInfo[0].close;

   // Tag und Monat
   if (startMonth < currentPrice && startToday < currentPrice) return 1.0;
   if (startMonth > currentPrice && startToday > currentPrice) return -1.0;

   return 0.0;
}

//+------------------------------------------------------------------+
// ATR-Filter
//+------------------------------------------------------------------+
//input double atrJPY = 0.04;

double CheckATR(string currentSymbol)
{
   double PreisArray[];
   ArraySetAsSeries(PreisArray,true);

   int handle = iATR(currentSymbol,PERIOD_M1,14);
   Sleep(100);
   CopyBuffer(handle,0,0,3,PreisArray);

   double value = NormalizeDouble(PreisArray[0], 5);

   // Außnahme für JPY
   if (StringFind(currentSymbol, "JPY", 0) != -1) {

      if (value > 0.08) return 0.0; // nicht kaufen
      //if (value < atrJPY) return 0.0; // nicht kaufen

      return 1.0; // kaufen
   }

   // Standard
   if (value > 0.00024) return 0.0; // nicht kaufen
   if (value < 0.00014) return 0.0; // nicht kaufen

   return 1.0; // kaufen
}

//+------------------------------------------------------------------+
// Swap als Filter-Richtung nutzen, wegen länger hängender Trades
//+------------------------------------------------------------------+
double CheckTrendSwap(string currentSymbol)
{
   if (SymbolInfoDouble(currentSymbol,SYMBOL_SWAP_LONG) > 0
    && SymbolInfoDouble(currentSymbol,SYMBOL_SWAP_SHORT) > 0) {

      if (SymbolInfoDouble(currentSymbol,SYMBOL_SWAP_LONG) > SymbolInfoDouble(currentSymbol,SYMBOL_SWAP_SHORT))
         return SymbolInfoDouble(currentSymbol,SYMBOL_SWAP_LONG); // buy
      else
         return -1 * SymbolInfoDouble(currentSymbol,SYMBOL_SWAP_SHORT); // sell
   }

   if (SymbolInfoDouble(currentSymbol,SYMBOL_SWAP_LONG) > 0)
      return SymbolInfoDouble(currentSymbol,SYMBOL_SWAP_LONG); // buy

   if (SymbolInfoDouble(currentSymbol,SYMBOL_SWAP_SHORT) > 0)
      return -1 * SymbolInfoDouble(currentSymbol,SYMBOL_SWAP_SHORT); // sell


   // auf einmal bekomme ich keine Swap-Werte mehr, daher:
   if (SymbolInfoDouble(currentSymbol,SYMBOL_SWAP_LONG) == 0
    && SymbolInfoDouble(currentSymbol,SYMBOL_SWAP_SHORT) == 0) {
      // beide Richtungen ermöglichen:
      // if (currentSymbol == "") return (MathRand() % 3) - 1;

      // long:
      if (currentSymbol == "AUDCHF") return 1;
      if (currentSymbol == "AUDJPY") return 1;
      if (currentSymbol == "CADCHF") return 1;
      if (currentSymbol == "EURJPY") return 1;
      if (currentSymbol == "EURCHF") return 1;
      if (currentSymbol == "GBPJPY") return 1;
      if (currentSymbol == "GBPCHF") return 1;
      if (currentSymbol == "USDJPY") return 1;
      if (currentSymbol == "USDCHF") return 1;
      // short:
      if (currentSymbol == "AUDUSD") return -1;
      if (currentSymbol == "EURAUD") return -1;
      if (currentSymbol == "EURGBP") return -1;
      if (currentSymbol == "EURUSD") return -1;
      if (currentSymbol == "EURNZD") return -1;
      if (currentSymbol == "GBPUSD") return -1;
      // gar nicht, da beides negativ:
      if (currentSymbol == "CHFJPY") return 0;
      if (currentSymbol == "USDCAD") return 0;
   }
   return 0.0;
}


//+------------------------------------------------------------------+
// Offene Positionen: Profit pro Richtung berechnen
//+------------------------------------------------------------------+
int openPositions = 0;
int openBuyPositions = 0;
int openSellPositions = 0;
double openProfit = 0.0;
double openBuyProfit = 0.0;
double openSellProfit = 0.0;

void calculatePositions(string currentSymbol = "")
{
   // vor der Neuberechnung zurück setzen:
   openPositions = 0;
   openBuyPositions = 0;
   openSellPositions = 0;
   openProfit = 0.0;
   openBuyProfit = 0.0;
   openSellProfit = 0.0;

   ForEachPosition(positionid,index) {
      if (PositionGetInteger(POSITION_MAGIC) == MAGIC) {

         if (currentSymbol == "" || currentSymbol == PositionGetString(POSITION_SYMBOL)) {

            openProfit += PositionGetDouble(POSITION_PROFIT);
            openPositions++;

            if ((ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY) {
               openBuyProfit += PositionGetDouble(POSITION_PROFIT);
               openBuyPositions++;
            }
            if ((ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_SELL) {
               openSellProfit += PositionGetDouble(POSITION_PROFIT);
               openSellPositions++;
            }
         }
      }
   }
}

//+------------------------------------------------------------------+
// InfoBox
//+------------------------------------------------------------------+
void ChartWrite(string  name,
                string& comments[],
                int     x_distance,
                int     y_distance,
                int     FontSize = 10,
                color   clr = clrYellow,
                int     diff = 23)
{
   for(int i=0; i<ArraySize(comments); i++) {
      ChartWrite(name+"-"+(string)i, comments[i], x_distance, y_distance+=diff, FontSize, clr);
   }
}

//+------------------------------------------------------------------+
// InfoBox
//+------------------------------------------------------------------+
void ChartWrite(string  name,
                string  comment,
                int     x_distance,
                int     y_distance,
                int     FontSize = 10,
                color   clr = clrWhite)
{
   string boxName = "BGCOLOR";

   // Hintergrundbox
   if (ObjectFind(0, boxName) < 0) {
      ObjectCreate(0, boxName, OBJ_RECTANGLE_LABEL, 0, 0, 0);
   }
   ObjectSetInteger(0, boxName, OBJPROP_BGCOLOR, ChartGetInteger(0,CHART_COLOR_BACKGROUND,0));
   ObjectSetInteger(0, boxName, OBJPROP_BORDER_TYPE, BORDER_FLAT); // schwarzer Rand nicht änderbar
   ObjectSetInteger(0, boxName, OBJPROP_XDISTANCE, x_distance);
   ObjectSetInteger(0, boxName, OBJPROP_YDISTANCE, 23);
   ObjectSetInteger(0, boxName, OBJPROP_XSIZE, 200);
   ObjectSetInteger(0, boxName, OBJPROP_YSIZE, 200);

   // Inhalte
   ObjectCreate(0,     name, OBJ_LABEL, 0, 0, 0);
   ObjectSetInteger(0, name, OBJPROP_CORNER, CORNER_LEFT_UPPER);
   ObjectSetInteger(0, name, OBJPROP_COLOR, clr);
   ObjectSetString(0,  name, OBJPROP_TEXT, comment);
   ObjectSetInteger(0, name, OBJPROP_FONTSIZE, FontSize);
   ObjectSetString(0,  name,  OBJPROP_FONT, "Lucida Console");
   ObjectSetInteger(0, name, OBJPROP_SELECTABLE, false);
   ObjectSetInteger(0, name, OBJPROP_XDISTANCE, x_distance);
   ObjectSetInteger(0, name, OBJPROP_YDISTANCE, y_distance);
   ObjectSetInteger(0, name, OBJPROP_BACK, false);
}

//+------------------------------------------------------------------+
// Ask & Bid für MultiForex
//+------------------------------------------------------------------+
double GetAsk(string currentSymbol)
{
    MqlTick lastTick;
    SymbolInfoTick(currentSymbol, lastTick);
    return(lastTick.ask);
}
double GetBid(string currentSymbol)
{
    MqlTick lastTick;
    SymbolInfoTick(currentSymbol, lastTick);
    return(lastTick.bid);
}

//+------------------------------------------------------------------+
// Kaufe 0.01 Lot
//+------------------------------------------------------------------+
void OpenBuyOrder(string currentSymbol)
{
   if (!MQLInfoInteger(MQL_TRADE_ALLOWED)) return;

   MqlTradeRequest myrequest;
   MqlTradeResult myresult;
   ZeroMemory(myrequest);

   // Ask und Bid Preis für wechselnde Symbole
   double Ask = GetAsk(currentSymbol);
   double Bid = GetBid(currentSymbol);

   myrequest.magic = MAGIC;
   myrequest.action = TRADE_ACTION_DEAL;
   myrequest.type = ORDER_TYPE_BUY;
   myrequest.symbol = currentSymbol;
   myrequest.volume = 0.01;
   myrequest.type_filling = ORDER_FILLING_FOK;
   myrequest.price = SymbolInfoDouble(currentSymbol,SYMBOL_ASK);
   myrequest.tp = Ask + (ProfitPunkte * SymbolInfoDouble(currentSymbol,SYMBOL_POINT));
   myrequest.sl = StoplossPunkte == 0 ? 0 : Bid - (StoplossPunkte * SymbolInfoDouble(currentSymbol,SYMBOL_POINT));
   myrequest.deviation = 50;
   myrequest.comment = "V" + VERSION;

   bool err = OrderSend (myrequest,myresult);
}

//+------------------------------------------------------------------+
// Verkaufe 0.01 Lot
//+------------------------------------------------------------------+
void OpenSellOrder(string currentSymbol)
{
   if (!MQLInfoInteger(MQL_TRADE_ALLOWED)) return;

   MqlTradeRequest myrequest;
   MqlTradeResult myresult;
   ZeroMemory(myrequest);

   // Ask und Bid Preis für wechselnde Symbole
   double Ask = GetAsk(currentSymbol);
   double Bid = GetBid(currentSymbol);

   myrequest.magic = MAGIC;
   myrequest.action = TRADE_ACTION_DEAL;
   myrequest.type = ORDER_TYPE_SELL;
   myrequest.symbol = currentSymbol;
   myrequest.volume = 0.01;
   myrequest.type_filling = ORDER_FILLING_FOK;
   myrequest.price = SymbolInfoDouble(currentSymbol,SYMBOL_BID);
   myrequest.tp = Bid - (ProfitPunkte * SymbolInfoDouble(currentSymbol,SYMBOL_POINT));
   myrequest.sl = StoplossPunkte == 0 ? 0 : Ask + (StoplossPunkte * SymbolInfoDouble(currentSymbol,SYMBOL_POINT));
   myrequest.deviation = 50;
   myrequest.comment = "V" + VERSION;

   bool err = OrderSend (myrequest,myresult);
}

//+------------------------------------------------------------------+
// MQL4 Funktionen, die mir fehlen
//+------------------------------------------------------------------+
int Day() {
    MqlDateTime tm;
    TimeCurrent(tm);
    return(tm.day);
}
int DayOfWeek() {
    MqlDateTime tm;
    TimeCurrent(tm);
    return(tm.day_of_week);
}
int DayOfYear() {
    MqlDateTime tm;
    TimeCurrent(tm);
    return(tm.day_of_year);
}
int Hour() {
    MqlDateTime tm;
    TimeCurrent(tm);
    return(tm.hour);
}
int Minute() {
    MqlDateTime tm;
    TimeCurrent(tm);
    return(tm.min);
}
int Month() {
    MqlDateTime tm;
    TimeCurrent(tm);
    return(tm.mon);
}
int Seconds() {
    MqlDateTime tm;
    TimeCurrent(tm);
    return(tm.sec);
}
int Year() {
    MqlDateTime tm;
    TimeCurrent(tm);
    return(tm.year);
}
//+------------------------------------------------------------------+