Eine Art Martingale Strategie? Hilfe!

[edition87]

Hallo erst einmal an alle!

ich bin noch sehr neu in dem Thema MQL4 Programmiersprache, aber konnte schon erste Erfolge verzeichnen.
nur komm ich jetzt leider iwie nicht mehr weiter

Mein EA öffnet zu jeder neuen H1 Kerze (Zeitraum ist einstellbar) eine Sell-Order mit einem einstellbaren SL und TP.

Wenn die Sell-Order weder in den SL, noch in den TP wandert, wird sie nach einer Stunde wieder geschlossen.

Wurde die letzte Order nach einer Stunde geschlossen oder ist in den SL gelaufen, Sollen bei der nächsten H1 Kerze 4 identische Sell-Orders ausgelöst.
D.h. gleicher TP, gleicher SL etc.
Sind die 4 Sell-Orders wieder wieder nach einer Stunde geschlossen worden oder in den SL gelaufen, sollen bei der nächsten H1 Kerze 8 Sell Orders geöffnet werden, etc.

-> Da liegt leider auch mein Problem! Mein EA öffnet nicht bei der nächsten H1 Kerze die 4 Orders, sondern sofort nachdem die vorherige Sell-Order denn SL bzw. den TP erreicht hat.
auch der SL, TP wird nur bei der ersten der 4 Orders angepasst.

Hoffentlich konnte ich es verständlich rüber bringen
und vielleicht hat jemand einen Denkanstoß für mich.

Einen Schönen Abend noch

[Max2018]

mmmh scheint der ganze EA irgendwie nicht richtig aufgesetzt zu sein (Eine Meinung eines Mittelanfängers wie mir )

[MA-EA]

Lad mal hoch.

Aber Martin Gale ist - na ja. Eine richtige schlechte Zeit und man macht mehr Verluste als man je wieder rein holen kann...

Vielleicht könnte man woanders mal nen Diskussion über MG starten.

[edition87]

Zitat von Max2018

mmmh scheint der ganze EA irgendwie nicht richtig aufgesetzt zu sein (Eine Meinung eines Mittelanfängers wie mir )

#
Will ich definitiv nicht abstreiten. Wie bereits erwähnt, bin ich noch nicht sehr lange in der Materie und auf jeden Fall noch in der Lernphase - aber wer ist das nicht.

Hier mal der Code:

extern int MagicNummer = 12345;
extern int StartHour = 10;
extern int EndHour = 12;
extern double HandelsLots= 0.1, SL_Punkte = 2.5, TP_Punkte = 0.0;

datetime NeueKerze;
bool NeuePeriodeBegonnen, ZeitfensterOffen, ZeitfensterGeschlossen, LongSignal, LastTradeLose;
int CurrentTime, Ticket, ShortOrder;

int openbuy = 0;
int opensell = 0;


//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//---
   
//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//---
   
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
   {
      //Überprüfen ob neue Kerze vorliegt:
         if(NeueKerze != Time[0])
            {
               NeuePeriodeBegonnen = true; 
               NeueKerze = Time[0];
               Print("Neue Kerze Vorhanden");
            }
               else NeuePeriodeBegonnen = false;
               Print("Keine Neue Kerze Vorhanden");
               
      //Überprüfen ob wir uns im Zeitfenster befinden:
         CurrentTime = TimeHour(TimeCurrent());
            {
               if((CurrentTime >= StartHour) && (CurrentTime < EndHour))
                  {  
                     ZeitfensterOffen = true; 
                     Print("Zeitfenster geöffnet");
                  }
                     else ZeitfensterOffen = false;
                     Print("Zeitfenster geschlossen");
            }      
       
      //Bedingungen prüfen und Short-Order platzieren:
         if((NeuePeriodeBegonnen == true) && (ZeitfensterOffen == true))
            {
               ShortOrder=OrderSend(Symbol(),OP_SELL,HandelsLots,Bid,100,0.0,0.0,"Trade offen",MagicNummer,0,Blue);
            }  
            
      //SL Short Deals setzen:
         if(OrderSelect(ShortOrder,SELECT_BY_TICKET)==true)
            {
               if(OrderCloseTime()==0 && OrderStopLoss()==0)
                  {
                     double StoppLoss = NormalizeDouble(OrderOpenPrice()+(SL_Punkte/10000),Digits);
                     bool OrderAngepasst = OrderModify(OrderTicket(),OrderOpenPrice(),StoppLoss,OrderTakeProfit(),0,Yellow);          
                  }
            }
                              
      //TP Short Deals setzen:
         if(OrderSelect(ShortOrder,SELECT_BY_TICKET)==true)
            {
               if(OrderCloseTime()==0 && OrderTakeProfit()==0)
                  {
                     double TakeProfit = NormalizeDouble(OrderOpenPrice()-(TP_Punkte/10000),Digits);
                     bool OrderAngepasst = OrderModify(OrderTicket(),OrderOpenPrice(),OrderStopLoss(),TakeProfit,0,Orange);
                  }
            }
         
      //Neuer Befehl Order max. 1 Stunde geöffnet lassen!
         for(int i = OrdersTotal() - 1; i >= 0; i--)                            
         if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
            {
               if((OrderOpenTime()+3600) < TimeCurrent())
                  { 
                     if (OrderType() == OP_SELL)          
                        {
                           bool Closed = OrderClose(OrderTicket() ,OrderLots(), Bid, 10, Red);  
                           opensell = 0;         
                        }              
                  }
            }
       
   //Wenn letzter Trade nicht in den TP gelaufen ist, beim nächsten Trade 4 Positionen eröffnen
      for (int i = 0; i < 1; i++)                         
         if(OrderSelect(i, SELECT_BY_POS, MODE_HISTORY))
            {
               if(OrderProfit()<0.0)
               {
                  ShortOrder=OrderSend(Symbol(),OP_SELL,HandelsLots,Bid,100,0.0,0.0,"Trade offen",MagicNummer,0,Blue);
                  ShortOrder=OrderSend(Symbol(),OP_SELL,HandelsLots,Bid,100,0.0,0.0,"Trade offen",MagicNummer,0,Blue); 
               }              
            }       


      //Ticketnummern nach Closing auf 0 zurücksetzen:
         if(OrderSelect(ShortOrder,SELECT_BY_TICKET)==true)
            {
               if(OrderTicket()>0 && OrderCloseTime()>0) ShortOrder=0;
            }       
   }

Ich bin für jeden Kommentar, von totaler Schrott bis hin zu erste erkennbare Ansätze, dankbar.

[MA-EA]

Wenn bloß zu jeder neuen Stunde geöffnet werden soll, reichts eigentlich Hour() zu speichern.

Ich versteh nicht, wie Du den SL und TP berechnest. Letzterer steht übrigens auf 0.

Wenn Du viele Orders auf ein mal öffnen willst, könntest Du das vielleicht mit ner for Schleife machen.

Aber zur eigentlichen Frage: Wo und wann aktualisierst Du dieses Zeit-Speicher-Array? Ich seh zwar, dass das Ding abgefragt wird, aber der alte Wert wird anscheinend nie durch die neue Stunde ersetzt.

[daybyter]

Die letzte for Schleife zum Eröffnen der 4 Orders läuft von 0 bis 0 ?

[edition87]

Zitat von MA-EA

Wenn bloß zu jeder neuen Stunde geöffnet werden soll, reichts eigentlich Hour() zu speichern.

Ja das würde natürlich auch funktionieren und der Code wäre etwas einfacher.

Zitat von MA-EA

Ich versteh nicht, wie Du den SL und TP berechnest. Letzterer steht übrigens auf 0.

Hier wird der SL und TP gesetzt. Externe Variable.

 //SL Short Deals setzen:
         if(OrderSelect(ShortOrder,SELECT_BY_TICKET)==true)
            {
               if(OrderCloseTime()==0 && OrderStopLoss()==0)
                  {
                     double StoppLoss = NormalizeDouble(OrderOpenPrice()+(SL_Punkte/10000),Digits);
                     bool OrderAngepasst = OrderModify(OrderTicket(),OrderOpenPrice(),StoppLoss,OrderTakeProfit(),0,Yellow);          
                  }
            }
                              
      //TP Short Deals setzen:
         if(OrderSelect(ShortOrder,SELECT_BY_TICKET)==true)
            {
               if(OrderCloseTime()==0 && OrderTakeProfit()==0)
                  {
                     double TakeProfit = NormalizeDouble(OrderOpenPrice()-(TP_Punkte/10000),Digits);
                     bool OrderAngepasst = OrderModify(OrderTicket(),OrderOpenPrice(),OrderStopLoss(),TakeProfit,0,Orange);
                  }
            }

Zitat von MA-EA

Wenn Du viele Orders auf ein mal öffnen willst, könntest Du das vielleicht mit ner for Schleife machen.

Muss ich dann immer abfragen, ob gerade eine Order geöffnet wurde? und wenn ja soll er noch weitere öffnen?

Zitat von MA-EA

Aber zur eigentlichen Frage: Wo und wann aktualisierst Du dieses Zeit-Speicher-Array? Ich seh zwar, dass das Ding abgefragt wird, aber der alte Wert wird anscheinend nie durch die neue Stunde ersetzt.

Ich hab ein Array? Sorry für die blöde Frage. Da weiß ich dann wohl selbst nicht was ich da für einen Code geschrieben habe.
Was ist denn ein Zeit-Speicher-Array und wo frage ich den ab?

[edition87]

Zitat von daybyter

Die letzte for Schleife zum Eröffnen der 4 Orders läuft von 0 bis 0 ?

Wirklich? Dann liegt es daran dass er die letzten geschlossenen Orders nicht richtig zählt.

for (int i = 0; i < 1; i++)

int i = 0 besagt doch, dass er bei der letzten Order Anfangen soll zu zählen, oder?

i<1 die Bedeutung habe ich noch nicht ganz kapiert

i++ bedeutet er soll vorwärts zählen? Richtig? Dann ist da der Fehler, denn es müsste lauten, i--, oder? Wenn er bei der letzten Order anfängt vorwärts zu zählen, kommt ja logischerweise nichts mehr.

[MA-EA]

SL und TP kann man auf jeden Fall in einem Rutsch nach reichen. Da braucht man nicht 2x OrderSelect() machen.

++ einen int-Wert um 1 erhöhen

-- einen int-Wert um 1 senken


Leider hab ich diese Schleifen nie kapiert. Aber man könnte in den GV festlegen lassen, wie viele Orders auf einmal offen sein sollen. Z.B.

extern int Max_Offene_Orders = 4;

Dann wie normal Orders zählen lassen. Wenns weniger als Max_Offene_Orders sind, in der Schleife ne Weitere öffnen lassen. i-- nicht vergessen.

Aber wie gesagt bin aus den Schleifen nie schlau geworden. Kann die mal Jemand ganz genau und leicht verständlich erklären?

[edition87]

Danke für den Hinweis mit dem SL und TP. Da werd ich mich mal dran mach und versuchen wie ich das unter eine OrderSelect Abfrage bekomme

Ich glaube ich habe meine Strategie nicht ganz klar definiert.

Sagen wir mal, um 9 Uhr geht die erste Order in den Markt. Läuft sie in den TP, ist alles fein
Wenn nicht, dann läuft sie höchstwahrscheinlich in den SL oder sie wird eben nach einer Stunde wieder geschlossen. Ganz egal ob mit Gewinn oder Verlust.

Wenn die um 9 Uhr geöffnete Order nicht in den TP läuft, sollen um 10 Uhr 4 Orders mit der selben Lot-Size, dem gleichen TP uns SL ausgeführt werden.
Laufen diese 4 Orders wieder nicht in den TP, sollen um 11 Uhr 13 Orders gleichen Typs ausgeführt werden.
Laufen auch diese wieder nicht in den TP, sollen um 12 Uhr 40 Orders gleichen Typs ausgeführt werden. Usw., usw. ...
Bist halt wieder der TP erreicht. Dann beginnt das Spiel wieder von vorne.

Schematisch so dargestellt:

1 Trade (1 Order) - TakeProfit
2 Trade (1 Order) - TakeProfit
3 Trade (1 Order) - StoppLoss
4 Trade (4 Orders) - StoppLoss
5 Trade (13 Orders) - TakeProfit
6 Trade (1 Order) - ...


Wie gesagt, den ersten Teil konnte ich bereits umsetzten (wahrscheinlich eh das einfachste gewesen)

Aber ich denke, ich muss dann die Orders zählen lassen. Jedenfalls versuche ich dass (mit wenig Erfolg) gerade so umzusetzen.