float avg_movement= MathAbs(High[1]-Low[1])+MathAbs(High[2]-Low[2])+ MathAbs(High[3]-Low[3])+ MathAbs(High[4]-Low[4])+ MathAbs(High[5]-Low[5])+ MathAbs(High[6]-Low[6]);

int aktuellezeit=h*60+m;
if(aktuellezeit >= 21*60 +01 && aktuellezeit <= 14*60 +29){

if(avg_move>highest_avg_move)  highest_avg_move=avg_move;

//+------------------------------------------------------------------+
//|                SHARK_Stochastic_CLASSIC_V.2.1.0 - 1121           |
//|                         Copyright 2021                           |
//|                      www.companyname.net                         |
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//|                       Farbenauswahl                              |
//|                                                                  |
//| Farbe 01 - C'35,248,48' - Grün                                   |
//| Farbe 02 - C'204,0,15'  - Rot                                    |
//| Farbe 03 - C'93,219,231'- Hellblau                               |
//| Farbe 04 - C'248,86,13' - Orange                                 |
//| Farbe 05 - C'204,0,183' - Magenta                                |
//| Farbe 06 - C'64,121,246'- Dunkelblau                             |
//| Farbe 07 - C'237,252,255'-Weiß                                   |
//| Farbe 07 - C'254,239,79'- Hellgelb                               |
//|                                                                  |
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
#property indicator_separate_window
#property indicator_buffers  5

#property indicator_minimum 0
#property indicator_maximum 100

extern string SETTING = "";

extern int    K_PERIOD =  5;
extern int    D_PERIOD =  3;
extern int     Slowing =  3;

extern int Upper_Limit = 80;
extern int Lower_Limit = 20;

extern ENUM_MA_METHOD  StoSignalMethod = MODE_SMA;

extern ENUM_APPLIED_PRICE APPLEY = PRICE_CLOSE;
extern ENUM_STO_PRICE PRICE_RANGE = 0;

extern string STYL = "";

extern color Upper_Color = C'204,0,15';
extern color Lower_Color = C'35,248,48';
extern color Hlines_Background = C'51,31,52';

extern string ALARM = "";


//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
string PriceTypeToString(int pt)
  {
   string answer;
   switch(pt)
     {
      case 0:
         answer = "Close"    ;
         break;
      case 1:
         answer = "Open"     ;
         break;
      case 2:
         answer = "High"     ;
         break;
      case 3:
         answer = "Low"      ;
         break;
      case 4:
         answer = "Median"   ;
         break;
      case 5:
         answer = "Typical"  ;
         break;
      case 6:
         answer = "Wighted"  ;
         break;
      default:
         answer = "Invalid price field requested";
         Alert(answer);
     }
   return(answer);
  }


string Name ="SHARK_STOCHASTIC_CLASSIC_V.2.1.0 - 1121 " + "("+K_PERIOD +","+ D_PERIOD+","+Slowing+","+PriceTypeToString(APPLEY)+","+Upper_Limit+","+Lower_Limit+")";


//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+

int windowIndex=WindowFind(Name);

// ==================================== rectangle names
string NameTopLev=windowIndex+"LevelTop";       //50 -
string NameWaitUp=windowIndex+"LevelWaitTop";   // 55
string NameWaitLo=windowIndex+"LevelWaitBot";   //-45
string NameBotLev=windowIndex+"LevelBot";       //30


//+------------------------------------------------------------------+
//|  Buffer                                                          |
//+------------------------------------------------------------------+
double SHARK_BUFFER_M[],SHARK_BUFFER_S[],SHARK_BUFFER_UP[],SHARK_BUFFER_DN[],SHARK_BUFFER_SIGNAL[];

bool initFinished=false;
datetime time_alert;

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int init()
  {
   IndicatorBuffers(5);
   IndicatorDigits(Digits);//max. 2

   SetIndexBuffer(0,SHARK_BUFFER_M,INDICATOR_DATA);
   SetIndexStyle(0,DRAW_LINE,EMPTY,1,C'64,121,246');
   SetIndexLabel(0,"MAIN");

   SetIndexBuffer(1,SHARK_BUFFER_S,INDICATOR_DATA);
   SetIndexStyle(1,DRAW_LINE,EMPTY,1,C'204,0,15');
   SetIndexLabel(1,"SIGNAL");

   SetIndexBuffer(2,SHARK_BUFFER_UP,INDICATOR_DATA);
   SetIndexStyle(2,DRAW_ARROW,EMPTY,2,C'0,255,0');
   SetIndexArrow(2,159);
   SetIndexLabel(2,NULL);

   SetIndexBuffer(3,SHARK_BUFFER_DN,INDICATOR_DATA);
   SetIndexStyle(3,DRAW_ARROW,EMPTY,2,C'255,0,0');
   SetIndexArrow(3,159);
   SetIndexLabel(3,NULL);

   SetIndexBuffer(4,SHARK_BUFFER_SIGNAL,INDICATOR_DATA);
   SetIndexStyle(4,DRAW_NONE,EMPTY,1,clrNONE);
   SetIndexLabel(4,"TREND");

   return(0);
  }

//+------------------------------------------------------------------+
//| Custom indicator deinitialization function                       |
//+------------------------------------------------------------------+
int deinit()
  {
   ObjectsDeleteAll();
// Löschen wir alle Objekte

   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int start()
  {
   _CreateLevelChanel(Upper_Limit,Lower_Limit,Hlines_Background);
   _Upper_Lower_Line(Upper_Limit,Lower_Limit,Upper_Color,Lower_Color);





   int counted_bars=IndicatorCounted(),limit,i;

   if(counted_bars<0)
      return(-1);
   if(counted_bars>0)
      counted_bars--;

   limit=MathMin(Bars-counted_bars,Bars-1);




   for(i = limit; i >= 0 && !IsStopped(); i--)
     {
      SHARK_BUFFER_M[i]= iStochastic(Symbol(),Period(),K_PERIOD,D_PERIOD,Slowing,StoSignalMethod,PRICE_RANGE,MODE_MAIN,i);
      SHARK_BUFFER_S[i]= iStochastic(Symbol(),Period(),K_PERIOD,D_PERIOD,Slowing,StoSignalMethod,PRICE_RANGE,MODE_SIGNAL,i);
      SHARK_BUFFER_SIGNAL[i] = SHARK_BUFFER_M[i] - SHARK_BUFFER_S[i];

      //+------------------------------------------------------------------+
      //| LONG - TRENDSIGNAL                                               |
      //+------------------------------------------------------------------+
      if(((SHARK_BUFFER_S[i] >= 20) && ( SHARK_BUFFER_S[i+1] <= 20 )) || ((SHARK_BUFFER_M[i] >= 20) && ( SHARK_BUFFER_M[i+1] <= 20 ) && (SHARK_BUFFER_M[i] > SHARK_BUFFER_S[i]) &&( SHARK_BUFFER_S[i] < 20 )) )
        {
         SHARK_BUFFER_UP[i+1] = SHARK_BUFFER_M[i+1];  SHARK_BUFFER_UP[i+1] = SHARK_BUFFER_S[i+1];
        }
      //+------------------------------------------------------------------+
      //| SHORT - TRENDSIGNAL                                                   |
      //+------------------------------------------------------------------+
      if(((SHARK_BUFFER_S[i] <= 80) && ( SHARK_BUFFER_S[i+1] >= 80 )) || ((SHARK_BUFFER_M[i] <= 80) && ( SHARK_BUFFER_M[i+1] >= 80 ) && (SHARK_BUFFER_M[i] < SHARK_BUFFER_S[i]) &&( SHARK_BUFFER_S[i] > 80 )))
        {
          SHARK_BUFFER_DN[i+1] = SHARK_BUFFER_M[i+1];SHARK_BUFFER_DN[i+1] = SHARK_BUFFER_S[i+1];
        }







     }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
   return(0);
  }



//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void _CreateLevelChanel(int Upper, int Lower, color BG)
  {
   if(true)
     {
      if(ObjectFind(0,NameTopLev)!=windowIndex)
         if(!ObjectCreate(0,NameTopLev,OBJ_RECTANGLE,windowIndex,
                          Bars-1,80,                     //ChartBegin,70
                          Time[0],100)      //Now,100
           )
            Print(__FUNCTION__+" "+NameTopLev+" failed, Code="+IntegerToString(_LastError));
      ObjectSetInteger(0,NameTopLev,OBJPROP_COLOR,C'2,51,4');

      if(ObjectFind(0,NameBotLev)!=windowIndex)
         if(!ObjectCreate(0,NameBotLev,OBJ_RECTANGLE,windowIndex,
                          Bars-1,20,                      //ChartBegin,50
                          Time[0],0)                    //Now,500
           )
            Print(__FUNCTION__+" "+NameBotLev+" failed, Code="+IntegerToString(_LastError));
      ObjectSetInteger(0,NameBotLev,OBJPROP_COLOR,C'51,0,4');
     }

  }

//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void _Upper_Lower_Line(int UPPER_HEIGHT, int LOWER_DEPTH, color HEIGHT_COLOR, color DEPTH_COLOR)
  {

   if(initFinished==false)
     {
      IndicatorShortName(Name);

      windowIndex=WindowFind(Name);

      if(windowIndex<0)
        {
         // wenn die Nummer des Unterfensters -1 gleich ist, so tritt der Fehler auf
         Print("Can\'t find window");
         //return(0);
        }
      //+------------------------------------------------------------------+
      //|  OVERBOUGHT BEREICH 80 %                                         |
      //+------------------------------------------------------------------+

      ObjectCreate("UPPERTEXT",OBJ_LABEL,windowIndex,0,LOWER_DEPTH);
      ObjectSet("UPPERTEXT",OBJPROP_XDISTANCE,5);
      ObjectSet("UPPERTEXT",OBJPROP_YDISTANCE,25);
      ObjectSetText("UPPERTEXT", "OVERBOUGHT",10,"Times New Roman",clrWhiteSmoke);

      // wir zeichnen die Linie im Unterfenster unseres Indikators
      ObjectCreate("Upperline",OBJ_HLINE,windowIndex,0,LOWER_DEPTH);
      ObjectSet("Upperline",OBJPROP_COLOR,HEIGHT_COLOR);
      ObjectSet("Upperline",OBJPROP_WIDTH,1);
      ObjectSet("Upperline",OBJPROP_STYLE,STYLE_DOT);
      WindowRedraw();
      // wir zeichnen das Fenster, damit wir die Linie sehen
      
      //+------------------------------------------------------------------+
      //|  OVERSOLD BEREICH 20 %                                           |
      //+------------------------------------------------------------------+
      ObjectCreate("LOWERTEXT",OBJ_LABEL,windowIndex,0,LOWER_DEPTH);
      ObjectSet("LOWERTEXT",OBJPROP_XDISTANCE,5);
      ObjectSet("LOWERTEXT",OBJPROP_YDISTANCE,175);
      ObjectSetText("LOWERTEXT", "OVERSOLD",10,"Times New Roman",clrWhiteSmoke);
      
      // wir zeichnen die Linie im Unterfenster unseres Indikators
      ObjectCreate("Lowerline",OBJ_HLINE,windowIndex,0,UPPER_HEIGHT);
      ObjectSet("Lowerline",OBJPROP_COLOR,DEPTH_COLOR);
      ObjectSet("Lowerline",OBJPROP_WIDTH,1);
      ObjectSet("Lowerline",OBJPROP_STYLE,STYLE_DOT);
      WindowRedraw();
      // wir zeichnen das Fenster, damit wir die Linie sehen

      initFinished=true;
      // Das Zeichen wurde schon beendet
     }


  }
//+------------------------------------------------------------------+

if((Buffer[i+1] < 30) && (Buffer[i] > 30))
{
BUFFER_ARROW_UP[i+1] = Low[i+1]+5;
}

Los_FiOrd = D_CAO + Spread;
Win_FiOrd = D_CAO - Spread;
LW_FiOrd = Los_FiOrd / Win_FiOrd;

Win_NeOrd = D_ONO - Spread;

LW_FiNe_Ord = Los_FiOrd / Win_NeOrd;

...

Lots_Sel = OrderLots() * LW_FiOrd * Lots_Multi;


Lots_Buy = OrderLots() * LW_FiOrd * Lots_Multi;


Lots_Sel=
    
L_LOSH * LW_FiNe_Ord * Lots_Multi;


Lots_Buy=
    
L_LOSH * LW_FiNe_Ord * Lots_Multi;

// 31.12.2021 V-2


#property strict

 input double Lots = 0.01;
 input int SLPoints = 500;
 input int TPPoints = 500;
 input int TSLPoint = 500;
 
 
 input ENUM_TIMEFRAMES Timeframe = PERIOD_H4; 
 input int PeriodsMAFast = 50;
 input ENUM_MA_METHOD MethdeMAFast = MODE_SMA;
 input int PeriodsMASlow = 200;
 input ENUM_MA_METHOD MethdeMASlow = MODE_SMA;
 
 input string Commententary = "Andy";
 input int Magic = 210879 ;
 
 datetime timestamp ;
  
int OnInit()
  {

   return(INIT_SUCCEEDED);
  }

void OnDeinit(const int reason)
  {

   
  }

void OnTick(){


   TrailingStop();  


   if(timestamp == iTime(Symbol(),Timeframe,0)) return ;
   timestamp = iTime(Symbol(),Timeframe,0);

  
   
    double maFast = iMA (Symbol(),Timeframe,PeriodsMAFast ,0,MethdeMAFast ,PRICE_CLOSE,1);
    double maSlow = iMA (Symbol(),Timeframe,PeriodsMASlow ,0,MethdeMASlow ,PRICE_CLOSE,1);
    double maFastLast = iMA (Symbol(),Timeframe,PeriodsMAFast ,0,MethdeMAFast ,PRICE_CLOSE,2);
    double maSlowLast = iMA (Symbol(),Timeframe,PeriodsMASlow ,0,MethdeMASlow ,PRICE_CLOSE,2); 
      
    if(maFast > maSlow && maFastLast <  maSlowLast ){
    Print("Long");
    int ticket = executeLong();
    Print(IntegerToString(ticket));
 
  }else if ( maFast < maSlow && maFastLast >  maSlowLast ){
   
    Print("Short");
    int ticket = executeShort() ;
    Print(IntegerToString(ticket));
   }
  }
 
   int executeLong ( ){
   double entry = Ask ;
   entry = NormalizeDouble (entry,Digits);
   
   double sl = entry - SLPoints * Point;
   sl= NormalizeDouble(sl,Digits);
   
   double tp = entry + TPPoints * Point;;
   tp = NormalizeDouble(tp,Digits);
   
   int ticket = OrderSend (Symbol(),OP_BUY,Lots,entry,1000,sl,tp,Commententary,Magic);
   
   return ticket;
   
    }  
   
   int executeShort (){
   double entry = Bid ;
   entry = NormalizeDouble (entry,Digits);
    
   double sl = entry + SLPoints * Point;
   sl= NormalizeDouble(sl,Digits);
   
   double tp = entry - TPPoints * Point;
   tp = NormalizeDouble(tp,Digits);
    
   int ticket = OrderSend (Symbol(),OP_SELL,Lots,entry,1000,sl,tp,Commententary,Magic);
   
   return ticket;
   
   }
     
  void TrailingStop(){
    for(int i = 0; i < OrdersTotal(); i++){
      if(OrderSelect(i,SELECT_BY_POS) && OrderSymbol() == Symbol() && OrderMagicNumber() == Magic ) {
        if(OrderType() == OP_BUY){
          double sl = Bid - TSLPoint * Point ;
          sl = NormalizeDouble(sl,Digits);
          if(sl > OrderStopLoss()){
            bool res = OrderModify(OrderTicket(),OrderOpenPrice(),sl,OrderTakeProfit(),OrderExpiration());
            
            }
            }
         if(OrderType() == OP_SELL){
          double sl = Ask + TSLPoint * Point ;
          sl = NormalizeDouble(sl,Digits);
          if(sl < OrderStopLoss() || OrderStopLoss() == 0){
            bool res = OrderModify(OrderTicket(),OrderOpenPrice(),sl,OrderTakeProfit(),OrderExpiration());   
            
            
            
         }
        }
       }
      }
     }

input ENUM_APPLIED_PRICE OnePr_Fast=PRICE_CLOSE;
input ENUM_APPLIED_PRICE OnePr_Slow=PRICE_TYPICAL;

OnePr_fa = iCustom(Symbol(),TF_Trading,

"OnePrice_CHA.ex4"
,
OnePr_Fast
,
0// Line Index ?
,
1// Bar 1
);

//-----------------------------------------------------------------------------------------------------------*/

OnePr_sl = iCustom(Symbol(),TF_Trading,

"OnePrice_CHA.ex4"
,
OnePr_Slow
,
0// Line Index ?
,
1// Bar 1
 );

/* string LaterTimeHHandMM(int HHhour=0, int MMminute=0, int HHadd=0, int MMadd=0)
   errechnet den späteren HH:MM Wert
   Hier die OnCalculate Zusammenfassung
*/
   for(int i=limit; i>=0; i--)
   {
      DayOfiWkDay=TimeDayOfWeek(Time[i]); //CurrentWeekdayofIndexnummber
      if(DayOfiWkDay>=WEEKSTART && DayOfiWkDay<=WEEKSTOP) //default:Mo-Fr
      {
         string SepHM=":";
         int SepHMpos=StringFind(HSTART,SepHM,0); //PositionOfHour:MinuteSeparator,=2
         int HHofStart=(int)StringToInteger( StringSubstr(HSTART,0,SepHMpos) );   //0 tillSep(WithoutSep)
         int MMofStart=(int)StringToInteger( StringSubstr(HSTART,SepHMpos+1,0) ); //1 afterSep
         string TmpLater= LaterTimeHHandMM(HHofStart, MMofStart,1,30);            //1:30
           //Print(HSTART," SepHMpos=",(int)SepHMpos,
           //      " HHofStart=",(int)HHofStart,
           //      " MMofStart=",(int)MMofStart,
           //      " from ",HSTART," 1:30 TmpLater=",TmpLater,
           //      " Time[i]=",TimeToStr(Time[i]),
           //      " DayOfiTDate+TmpLater=",DayOfiTDate+" "+TmpLater );
         if(Time[i]==StringToTime(DayOfiTDate+" "+TmpLater) )
            PaintVertLine("TrendStart"+TimeToStr(Time[i]),
                          Time[i]);
      }//Mo-Fr
   }//int i=limit; i>=0; i--

// ======================= Funktion zum Malen der Vertikalen
bool PaintVertLine(string name="VertBaseName", datetime VertTime=0)
{
   name=PFX+name;
   ResetLastError();
   if(ObjectFind(name)!=0)
      if(!ObjectCreate(0,name,OBJ_VLINE,0,VertTime,0))
         { Print(__FUNCTION__," failed ",name," Code=",_LastError); return(false); }
   //ObjectSetInteger(0,name,OBJPROP_TIME,VertTime);
   ObjectSetInteger(0,name,OBJPROP_COLOR,COLOROPCL9); 
   ObjectSetInteger(0,name,OBJPROP_STYLE,STYLE_DOT);
   ObjectSetInteger(0,name,OBJPROP_WIDTH,1);
   ObjectSetString(0,name,OBJPROP_TEXT,"Trend Trade Start");
   ObjectSetInteger(0,name,OBJPROP_BACK,true);
   ObjectSetInteger(0,name,OBJPROP_SELECTABLE,true); //make deleting possible
   ObjectSetInteger(0,name,OBJPROP_SELECTED,false); 
   return(true);
}
// =======================

...
08:00 SepHMpos=2 HHofStart=8 MMofStart=0 from 08:00 1:30 TmpLater=9:30 Time[i]=2021.12.09 09:15 DayOfiTDate+TmpLater=2021.12.09 9:45
08:00 SepHMpos=2 HHofStart=8 MMofStart=0 from 08:00 1:30 TmpLater=9:30 Time[i]=2021.12.09 09:30 DayOfiTDate+TmpLater=2021.12.09 9:45
08:00 SepHMpos=2 HHofStart=8 MMofStart=0 from 08:00 1:30 TmpLater=9:30 Time[i]=2021.12.09 09:45 DayOfiTDate+TmpLater=2021.12.09 9:45
...
08:00 SepHMpos=2 HHofStart=8 MMofStart=0 from 08:00 1:30 TmpLater=9:30 Time[i]=2021.12.10 09:15 DayOfiTDate+TmpLater=2021.12.10 9:45
08:00 SepHMpos=2 HHofStart=8 MMofStart=0 from 08:00 1:30 TmpLater=9:30 Time[i]=2021.12.10 09:30 DayOfiTDate+TmpLater=2021.12.10 9:45
08:00 SepHMpos=2 HHofStart=8 MMofStart=0 from 08:00 1:30 TmpLater=9:30 Time[i]=2021.12.10 09:45 DayOfiTDate+TmpLater=2021.12.10 9:45
...
08:00 SepHMpos=2 HHofStart=8 MMofStart=0 from 08:00 1:30 TmpLater=9:30 Time[i]=2021.12.10 20:45 DayOfiTDate+TmpLater=2021.12.10 9:45