/*=============================================================================================================
// N O T I Z E N   U N D   I N F O S
//=============================================================================================================


//-------------------------------------------------------------------------------------------------------------

In dieser Vers. ShLo_TI_v2.mq4...


- ...


- ...werden die OrderLots() der letzten Verlust-Order
     mit Lots_Multi erhöht.


- ...wird nur eine First-Order geöffnet.


- ...gibt es 2 OS.


- ...gibt es ? OC.



//-------------------------------------------------------------------------------------------------------------


//=============================================================================================================
// P R O P E R T Y
//============================================================================================================*/
//#property strict
//#ps sorgt anscheinend dafür, dass Kommentare im Konfig-Fenster im MT4 sichtbar sind.
#property copyright"ShLo_TI_v2.mq4"
#property copyright"daniel-rudloff@web.de"
//=============================================================================================================
// B E S C H R E I B U N G
//=============================================================================================================
extern string esTOY="true  = on / yes";
extern string esFON="false = off / no";
//=============================================================================================================
// E I N S T E L L U N G E N
//=============================================================================================================
extern string esOFO="Open First Order";
input bool Sel_noBuy=false;
input bool Buy_noSel=true;
//-----------------------------------------------------------------------------------------------------------*/
extern string esMN="Magic Numbers";
extern int MN_FirstSel=12;
extern int MN_FirstBuy=34;
extern int MN_NextSel=56;
extern int MN_NextBuy=78;
//-----------------------------------------------------------------------------------------------------------*/
extern string esOOFT1="Open Orders";
extern string esOOFT2="from/till Hour";
extern string esOOFT3="(Server Time)";
extern int FromH=4;//  Vor 4 Uhr starten scheint sich nicht zu lohnen.
extern int TillH=16;// Zum Testen bis einschließlich 16 Uhr öffnen.
//-----------------------------------------------------------------------------------------------------------*/
extern string esTF="TimeFrame";
input ENUM_TIMEFRAMES TF=1;// ? Zum Testen M1
//-----------------------------------------------------------------------------------------------------------*/
extern int Slippage=123456;
//-----------------------------------------------------------------------------------------------------------*/
extern int SL=200;// ? Zum Testen 200
//-----------------------------------------------------------------------------------------------------------*/
extern int TP=200;// ? Zum Testen 200
//-----------------------------------------------------------------------------------------------------------*/
extern string esITCBSMS1="if IsTradeContexBusy()";
extern string esITCBSMS2="sleep MS";
extern int slMS=80;// ? Zum Testen 80ms 
//-----------------------------------------------------------------------------------------------------------*/
extern string esDONO1="Dist to OrderOpenPrice()";
extern string esDONO2="open next Order";
extern int DONO=33;// ? Zum Testen 33 ( Verl. pro Order ca.  54  P ? )
//-----------------------------------------------------------------------------------------------------------*/
extern string esDCAO1="Dist to OrderOpenPrice()";
extern string esDCAO2="close all Orders";
extern int DCAO=35;// ? Zum Testen 35 ( Gew. pro Order ca.  15  P ? )
//-----------------------------------------------------------------------------------------------------------*/

extern string esL="Lots";

extern int Lots_Digits=2;

extern double Lots_Start=0.01;

extern double Lots_Multi=4.0;// ? Mindestens 3.0 ?

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

//=============================================================================================================
// G L O B A L E   D E K L A R A T I O N E N
//=============================================================================================================
bool

fiLO,fiSH,neLO,neSH,
OC// OrderClose

;
//-----------------------------------------------------------------------------------------------------------*/
double

SPR,// Spread

SL_Sel,SL_Buy,TP_Sel,TP_Buy,MSL,// MinStopLevel
DON_Sel,DON_Buy,
DCAO_Sel,DCAO_Buy,

Lots_Sel,Lots_Buy,

OL,// Lots einer bestimmten Order.

LSel_DTS,LSel_STD,LBuy_DTS,LBuy_STD

;
//-----------------------------------------------------------------------------------------------------------*/
int

i,

TI_FiSel,TI_FiBuy,TI_NeSel,TI_NeBuy

;
//=============================================================================================================
// L O T S
//=============================================================================================================

double mL = MarketInfo(Symbol(),MODE_MINLOT);
double Mr = MarketInfo(Symbol(),MODE_MARGINREQUIRED);

//=============================================================================================================
// I N I T
//=============================================================================================================
void OnInit(){ChartSetSymbolPeriod(0,NULL,TF);}
//=============================================================================================================
// E A   F U N K T I O N E N   S T A R T
//=============================================================================================================
void OnTick(){
//=============================================================================================================
// S T O P   L O S S
//=============================================================================================================
//SL auf 0 stellen, wenn oben <1, um irgendwelche Missverständnisse zu vermeiden.
if(SL<1){
  SL_Sel=0.0;
  SL_Buy=0.0;}
if(SL>0){
  SL_Sel=NormalizeDouble(Bid+SL*Point,Digits);
  SL_Buy=NormalizeDouble(Ask-SL*Point,Digits);}
//=============================================================================================================
// T A K E   P R O F I T
//=============================================================================================================
//TP auf 0 stellen, wenn oben <1, um irgendwelche Missverständnisse zu vermeiden.
if(TP<1){
  TP_Sel=0.0;
  TP_Buy=0.0;}
if(TP>0){
  TP_Sel=NormalizeDouble(Bid-TP*Point,Digits);
  TP_Buy=NormalizeDouble(Ask+TP*Point,Digits);}
//=============================================================================================================
// S P R E A D
//=============================================================================================================
SPR=DoubleToStr(Ask-Bid,Digits);


//=============================================================================================================
// O R D E R   S E A R C H   1
//=============================================================================================================
fiLO=false;
fiSH=false;
neLO=false;
neSH=false;
for(i=OrdersTotal()-1;i>=0;i--){
if(OrderSelect(i,SELECT_BY_POS)){
if(OrderSymbol()==Symbol()){
  if(OrderMagicNumber()==MN_FirstBuy)fiLO=true;
  if(OrderMagicNumber()==MN_FirstSel)fiSH=true;
  if(OrderMagicNumber()==MN_NextBuy)neLO=true;
  if(OrderMagicNumber()==MN_NextSel)neSH=true;}}}
//=============================================================================================================
//   O R D E R   C H E C K   1
//=============================================================================================================

// Wenn zur Zeit Orders geöffnet werden dürfen...
if( Hour()>=FromH && Hour()<=TillH ){

// ...wenn nach OS1/OC1 gar keine Orders offen sind...
  if( fiLO==false && fiSH==false && neLO==false && neSH==false ){

//=============================================================================================================
//   ( O C 1 )   O P E N   F I R S T   S E L / O P E N   F I R S T   B U Y
//=============================================================================================================

    if(Sel_noBuy==true){
      if(IsTradeAllowed())TI_FiSel=OrderSend(Symbol(),OP_SELL,Lots_Start,Bid,Slippage,SL_Sel,TP_Sel,NULL,MN_FirstSel,clrBlue);
      if(IsTradeContextBusy())Sleep(slMS);
      Print("-Spr=",DoubleToStr(SPR,Digits));}

    if(Buy_noSel==true){
      if(IsTradeAllowed())TI_FiBuy=OrderSend(Symbol(),OP_BUY,Lots_Start,Ask,Slippage,SL_Buy,TP_Buy,NULL,MN_FirstBuy,clrBlue);
      if(IsTradeContextBusy())Sleep(slMS);
      Print("-Spr=",DoubleToStr(SPR,Digits));}

} }// OS1/OC1 Time Check

//=============================================================================================================
// O R D E R   S E A R C H   2
//=============================================================================================================
fiLO=false;
fiSH=false;
neLO=false;
neSH=false;
for(i=OrdersTotal()-1;i>=0;i--){
if(OrderSelect(i,SELECT_BY_POS)){
if(OrderSymbol()==Symbol()){
  if(OrderMagicNumber()==MN_FirstBuy)fiLO=true;
  if(OrderMagicNumber()==MN_FirstSel)fiSH=true;
  if(OrderMagicNumber()==MN_NextBuy)neLO=true;
  if(OrderMagicNumber()==MN_NextSel)neSH=true;}}}
//=============================================================================================================
// ( O C 2 )   O P E N   N E X T S E L   B Y   F I R S T B U Y
//=============================================================================================================

// Wenn FirstBuy und noch kein NextBuy offen ist... 
if( fiLO==true && neLO==false ){

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


//...FirstBuy auswählen...
  if(OrderSelect(TI_FiBuy,SELECT_BY_TICKET)){

//  ...DCAO-Buy berechnen:
    DCAO_Buy = NormalizeDouble( OrderOpenPrice() + DCAO *Point,Digits);

//  ...DON_Sel berechnen:
    DON_Sel = NormalizeDouble( OrderOpenPrice() - DONO *Point,Digits);

//  Lots_Sel für NextSel berechnen:
    Lots_Sel = OrderLots() * Lots_Multi;

//  EA an FirstBuy-Ticket "erinnern".
    TI_FiBuy=OrderTicket();
  
  }// nach OC2 FirstBuy ausgewählt.


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


//Wenn FirstBuy unter DON_Sel ist...
  if( Bid < DON_Sel ){// ? Vermutlich Muss Bid unter DON_Sel sein?        


//  Wenn Sel über DCAO-Sel ist...
    if( Ask > DCAO_Sel ){// ?


//  ...prüfen, ob schon NextSel mit entsprechendem Lots_Sel-Ergebnis offen ist:
    OL=Lots_Start;
    for(i=OrdersTotal()-1;i>=0;i--){
    if(OrderSelect(i,SELECT_BY_POS)){
    if(OrderSymbol()==Symbol()){
      if( OrderMagicNumber()==MN_NextSel ){
        if( OrderLots() > OL )OL = OrderLots();}}}}

    LSel_DTS=DoubleToStr(Lots_Sel,Lots_Digits);
    LSel_STD=StrToDouble(LSel_DTS);


//  Wenn noch kein NextSel mit letzten NextSel-Lots offen ist... 
    if( LSel_STD > OL ){
  
//    ...NextSel öffnen:
      if(IsTradeAllowed())TI_NeSel=OrderSend(Symbol(),OP_SELL,LSel_STD,Bid,Slippage,SL_Sel,TP_Sel,NULL,MN_NextSel,clrNONE);
      if(IsTradeContextBusy())Sleep(slMS);

      }// kein NextSel mit Lots_NextSel-Ergebnis offen

    }// Bid über DCAO-Sel

  }// Bid unter DON_Sel

}// Nach OC2 noch kein NextBuy offen


//=============================================================================================================
// ( O C 2 )   O P E N   N E X T B U Y   B Y   F I R S T S E L
//=============================================================================================================

// Wenn nach OC2 FirstSel und noch kein NextSel offen ist...
if( fiSH==true && neSH==false ){

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


//FirstSel auswählen...
  if(OrderSelect(TI_FiSel,SELECT_BY_TICKET)){

//  D_CAO-Sel ausrechnen:    
    DCAO_Sel=NormalizeDouble( OrderOpenPrice() - DCAO *Point,Digits);

//  ...DON_Buy ausrechnen...
    DON_Buy=NormalizeDouble( OrderOpenPrice() + DONO *Point,Digits);

//  Lots_Buy berechnen...
    Lots_Buy = OrderLots() * Lots_Multi;

//  EA an FirstSel-Ticket "erinnern".
    TI_FiSel=OrderTicket();
  
  }// FirstSel ausgewählt


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


//Wenn FirstSel über DON_Buy ist...
  if( Ask > DON_Buy ){// ?


//  Wenn Buy unter DCAO-Buy ist...
    if( Bid < DCAO_Buy ){// ?
    
    
//  ...Prüfen, ob schon NextBuy mit entsprechendem Lots_Buy-Ergebnis offen ist:
    OL=Lots_Start;
    for(i=OrdersTotal()-1;i>=0;i--){
    if(OrderSelect(i,SELECT_BY_POS)){
    if(OrderSymbol()==Symbol()){
      if( OrderMagicNumber()==MN_NextBuy ){
        if( OrderLots() > OL )OL = OrderLots();}}}}

    LBuy_DTS=DoubleToStr(Lots_Buy,Lots_Digits);
    LBuy_STD=StrToDouble(LBuy_DTS);

//  Wenn noch kein NextBuy mit letzten Buy-Lots offen ist...
    if( LBuy_STD > OL ){

//    ...NextBuy öffnen...
      if(IsTradeAllowed())TI_NeBuy=OrderSend(Symbol(),OP_BUY,LBuy_STD,Ask,Slippage,SL_Buy,TP_Buy,NULL,MN_NextBuy,clrNONE);
      if(IsTradeContextBusy())Sleep(slMS);

      }// Kein Buy mit letztem Buy-Lots-Wert offen

    }// Ask unter DCAO-Buy
  
  }// Sel über DON_Buy

}// Nach OC2 noch kein NextSel offen


//=============================================================================================================
// ( O C 2 )   O P E N   N E X T S E L   B Y   N E X T B U Y
//=============================================================================================================

// Wenn nach OC2 doch NextBuy offen ist...
if( neLO==true ){

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


//...NextBuy auswählen...
  if(OrderSelect(TI_NeBuy,SELECT_BY_TICKET)){

//  ...DCAO-NextBuy berechnen:
    DCAO_Buy = NormalizeDouble( OrderOpenPrice() + DCAO *Point,Digits);

//  ...DON_Sel berechnen:
    DON_Sel = NormalizeDouble( OrderOpenPrice() - DONO *Point,Digits);

//  Lots_Sel für NextSel berechnen:
    Lots_Sel = OrderLots() * Lots_Multi;

//  EA an NextBuy-Ticket "erinnern".
    TI_NeBuy=OrderTicket();

  }// NextBuy ausgewählt.


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


//Wenn NextBuy unter DON_Sel ist...
  if( Bid < DON_Sel ){// ? Vermutlich Muss Bid unter DON_Sel sein?        


//  ...wenn NextSel über DCAO-Sel ist...
    if( Ask > DCAO_Sel ){// ?


//  ...prüfen, ob schon NextSel mit entsprechendem Lots_Sel-Ergebnis offen ist:
    OL=Lots_Start;
    for(i=OrdersTotal()-1;i>=0;i--){
    if(OrderSelect(i,SELECT_BY_POS)){
    if(OrderSymbol()==Symbol()){
      if( OrderMagicNumber()==MN_NextSel ){
        if( OrderLots() > OL )OL = OrderLots();}}}}

    LSel_DTS=DoubleToStr(Lots_Sel,Lots_Digits);
    LSel_STD=StrToDouble(LSel_DTS);


//  Wenn noch kein NextSel mit letzen NextSel-Lots offen ist... 
    if( LSel_STD > OL ){
  
//    ...NextSel öffnen:
      if(IsTradeAllowed())TI_NeSel=OrderSend(Symbol(),OP_SELL,LSel_STD,Bid,Slippage,SL_Sel,TP_Sel,NULL,MN_NextSel,clrNONE);
      if(IsTradeContextBusy())Sleep(slMS);

      }// kein NextSel mit Lots_NextSel-Ergebnis offen

    }

  }// Bid unter DON_Sel

}// Nach OC2 doch NextBuy offen


//=============================================================================================================
// ( O C 2 )   O P E N   N E X T B U Y   B Y   N E X T S E L
//=============================================================================================================

// Wenn nach OC2 doch NextSel offen ist...
if( neSH==true ){

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

//...NextSel auswählen...
  if(OrderSelect(TI_NeSel,SELECT_BY_TICKET)){

//  DCAO-Sel ausrechnen:    
    DCAO_Sel=NormalizeDouble( OrderOpenPrice() - DCAO *Point,Digits);

//  ...DON_Buy ausrechnen...
    DON_Buy=NormalizeDouble( OrderOpenPrice() + DONO *Point,Digits);

//  Lots_Buy berechnen...
    Lots_Buy = OrderLots() * Lots_Multi;

//  EA an NextSel-Ticket "erinnern".
    TI_NeSel=OrderTicket();
  
  }// NextSel ausgewählt

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


//Wenn NextSel über DON_Buy ist...
  if( Ask > DON_Buy ){// ?


//  Wenn Buy unter DCAO-Buy ist...
    if( Bid < DCAO_Buy ){// ?


//  ...Prüfen, ob schon NextBuy mit entsprechendem Lots_Buy-Ergebnis offen ist:
    OL=Lots_Start;
    for(i=OrdersTotal()-1;i>=0;i--){
    if(OrderSelect(i,SELECT_BY_POS)){
    if(OrderSymbol()==Symbol()){
      if( OrderMagicNumber()==MN_NextBuy ){
        if( OrderLots() > OL )OL = OrderLots();}}}}

    LBuy_DTS=DoubleToStr(Lots_Buy,Lots_Digits);
    LBuy_STD=StrToDouble(LBuy_DTS);

//  Wenn noch kein NextBuy mit letzten Buy-Lots offen ist...
    if( LBuy_STD > OL ){

//    ...NextBuy öffnen...
      if(IsTradeAllowed())TI_NeBuy=OrderSend(Symbol(),OP_BUY,LBuy_STD,Ask,Slippage,SL_Buy,TP_Buy,NULL,MN_NextBuy,clrNONE);
      if(IsTradeContextBusy())Sleep(slMS);


      }// Kein Buy mit letztem Buy-Lots-Wert offen

    }
  
  }// NextSel über DON_Buy

}// Nach OC2 doch NextSel offen


//=============================================================================================================
// C L O S E   A L L   O R D E R S
//=============================================================================================================

if( Ask <= DCAO_Sel || Bid >= DCAO_Buy ){

  Print("-Margin=",DoubleToStr(AccountMargin(),2));

  for(i=OrdersTotal()-1;i>=0;i--){
  if(OrderSelect(i,SELECT_BY_POS)){
  if(OrderSymbol()==Symbol()){

    if(OrderMagicNumber()==MN_FirstSel||OrderMagicNumber()==MN_NextSel){
      if(IsTradeAllowed())OC=OrderClose(OrderTicket(),OrderLots(),Ask,Slippage,clrNONE);
      if(IsTradeContextBusy())Sleep(slMS);}
  
    if(OrderMagicNumber()==MN_FirstBuy||OrderMagicNumber()==MN_NextBuy){
      if(IsTradeAllowed())OC=OrderClose(OrderTicket(),OrderLots(),Bid,Slippage,clrNONE);
      if(IsTradeContextBusy())Sleep(slMS);}

}}} }// DCAO erreicht

//=============================================================================================================
// E A   F U N K T I O N E N   B E E N D E N
//=============================================================================================================
}// void OnTick()

//
#property indicator_chart_window
#property indicator_buffers 2
#property indicator_color1 Blue
#property indicator_color2 Red
//---- input parameters
extern int Equals=5;
extern int nLeftUp=2;
extern int nRightUp=2;
extern int nLeftDown=2;
extern int nRightDown=2;
//---- buffers
double FractalsUp[];
double FractalsDown[];
//----
int pos=0,cntup=0,cntdown=0,cnt=0;
int r=0,l=0,e=0;
int fup=0,fdown=0;
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
  {
//---- indicators
   SetIndexBuffer(0,FractalsUp);
   SetIndexBuffer(1,FractalsDown);
//----
   SetIndexStyle(0,DRAW_ARROW,0,1);
   SetIndexArrow(0,217);
//----
   SetIndexStyle(1,DRAW_ARROW,0,1);
   SetIndexArrow(1,218);
//----
   cntup=nLeftUp+nRightUp+Equals+1;
   cntdown=nLeftDown+Equals+1;
   if(cntup>=cntdown)
      cnt=cntup;
   if(cntup<cntdown)
      cnt=cntdown;
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| Custor indicator deinitialization function                       |
//+------------------------------------------------------------------+
int deinit()
  {
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int start()
  {
   int i=0,j=0;
   int cbars=IndicatorCounted();
//----
   if(cbars<0)
      return(-1);
//----
   if(cbars>0)
      cbars--;
   pos=0;
//----
   if(cbars>(Bars-cnt-1))
      pos=(Bars-cnt-1);
   else
      pos=Bars -(cbars+nRightUp);
  if(cbars==0) pos-=Equals;       
//----
   while(pos>=nRightUp)
     {
      FractalsUp[pos]=NULL;
      FractalsDown[pos]=NULL;
      //ôÐÀÊÒÀË ÂÂÅÐÕ
      r=nRightUp; //ïðîâåðÿåì ïðàâóþ ñòîðîíó ôðàêòàëà
      //----
      for(i=1; i<=r; i++)
        {
         if(High[pos]<=High[pos-i])
            break;
        }
      //åñëè ñïðàâà âñå ÎÊ òî i äîëæíî áûòü ðàâíî r+1
      if(i==r+1) //FractalsUp[pos]=High[pos];
        {
         l=nLeftUp;  //ïðîâåðÿåì ëåâóþ ñòîðîíó ôðàêòàëà
         e= Equals;
         //----
         for(j=1; j<=l+Equals; j++)
           {
            if(High[pos]<High[pos+j])
               break;
            //----
            if(High[pos]>High[pos+j])
               l--;
            //----
            if(High[pos]==High[pos+j])
               e--;
            //----
            if(l==0)
              {
               FractalsUp[pos]=High[pos];
               break;
              }
            //----
            if(e<0)
               break;
           }
        }
      //ÔÐÀÊÒÀË ÂÍÈÇ
      r=nRightDown; //ïðîâåðÿåì ïðàâóþ ñòîðîíó ôðàêòàëà
      //----
      for(i=1; i<=r; i++)
        {
         if(Low[pos]>=Low[pos-i])
            break;
        }
      //----
      if(i==r+1) //FractalsUp[pos]=High[pos];
        {
         l=nLeftDown;  //ïðîâåðÿåì ëåâóþ ñòîðîíó ôðàêòàëà
         e= Equals;
         //----
         for(j=1; j<=l+Equals; j++)
           {
            if(Low[pos]>Low[pos+j])
               break;
            //----
            if(Low[pos]<Low[pos+j])
               l--;
            //----
            if(Low[pos]==Low[pos+j])
               e--;
            //----
            if(l==0)
              {
               FractalsDown[pos]=Low[pos];
               break;
              }
            if(e<0)
               break;
           }
        }
      pos--;
     }
//----
   return(0);
  }
//+------------------------------------------------------------------+

FP	0	07:16:06.333	Startup	MetaTester 5 x64 build 3320 (03 Jun 2022)
HF	0	07:16:06.341	Server	MetaTester 5 started on 127.0.0.1:3000
OO	0	07:16:06.343	Startup	initialization finished
NM	0	07:16:06.641	127.0.0.1	login (build 3320)
HJ	0	07:16:06.647	Network	4412 bytes of account info loaded
EL	0	07:16:06.647	Network	1478 bytes of tester parameters loaded
OI	0	07:16:06.647	Network	708 bytes of input parameters loaded
GO	0	07:16:06.647	Network	402 bytes of symbols list loaded (68 symbols)
GJ	0	07:16:06.648	Tester	expert file added: Experts\Advisors\1.ex5. 172075 bytes loaded
CK	0	07:16:06.649	Tester	7492 Mb available, 93 blocks set for ticks generating
PN	0	07:16:06.649	Tester	initial deposit 10000.00 USD, leverage 1:100
CK	0	07:16:06.650	Tester	successfully initialized
FQ	0	07:16:06.650	Network	169 Kb of total initialization data received
FD	0	07:16:06.650	Tester	AMD Ryzen 7 3700X 8-Core, 11998 MB
QL	0	07:16:06.656	Symbols	GBPUSD: symbol to be synchronized
LH	0	07:16:06.656	Symbols	GBPUSD: symbol synchronized, 3720 bytes of symbol info received
HL	0	07:16:06.657	History	GBPUSD: load 27 bytes of history data to synchronize in 0:00:00.000
DS	0	07:16:06.657	History	GBPUSD: history synchronized from 2020.01.01 to 2022.06.28
CK	0	07:16:06.721	History	GBPUSD,Daily: history cache allocated for 700 bars and contains 312 bars from 2020.01.01 00:00 to 2020.12.31 00:00
LI	0	07:16:06.721	History	GBPUSD,Daily: history begins from 2020.01.01 00:00
RH	0	07:16:06.722	Tester	GBPUSD,Daily (DecodeGlobal-Server): every tick generating
GE	0	07:16:08.316	History	GBPUSD,Monthly: history cache allocated for 32 bars and contains 12 bars from 2020.01.01 00:00 to 2020.12.01 00:00
OJ	0	07:16:08.316	History	GBPUSD,Monthly: 1 bar from 2021.01.01 00:00 added
DS	0	07:16:08.316	History	GBPUSD,Monthly: history begins from 2020.01.01 00:00
NI	2	07:16:08.392	History	: history cache build error
CP	2	07:16:08.472	History	: history cache build error
.....snip

//=============================================================================================================
// D E K L A R A T I O N   P R I C E
//=============================================================================================================

Pr_Hi=iHigh (NULL,NULL,i);
Pr_Op=iOpen (NULL,NULL,i);
Pr_Cl=iClose(NULL,NULL,i);
Pr_Lo=iLow  (NULL,NULL,i);

Pr_ME = ( Pr_Hi + Pr_Lo ) / 2.0;

Pr_TY = ( Pr_Hi + Pr_Cl + Pr_Lo ) / 3.0;

Pr_WE = ( Pr_Hi + Pr_Cl + Pr_Cl + Pr_Lo ) / 4.0;

// Zuweisung Price
if(Price==PRICE_HIGH    )PR=Pr_Hi;
if(Price==PRICE_CLOSE   )PR=Pr_Cl;
if(Price==PRICE_OPEN    )PR=Pr_Op;
if(Price==PRICE_LOW     )PR=Pr_Lo;
if(Price==PRICE_MEDIAN  )PR=Pr_ME;
if(Price==PRICE_TYPICAL )PR=Pr_TY;
if(Price==PRICE_WEIGHTED)PR=Pr_WE;

//=============================================================================================================
// D E K L A R A T I O N   M A
//=============================================================================================================

MA=iMA(Symbol(),Period(),MA_Period,MA_ChartShift,MA_Method,MA_Price,i);

//=============================================================================================================
// H P   D I V
//=============================================================================================================

HPdPR = ODIV(100.0// Soll dividiert werden
             ,
             PR// Wert, durch den dividiert werden soll
            );

HPdMA = ODIV(100.0// Soll dividiert werden
             ,
             MA// Wert, durch den dividiert werden soll
            );

//=============================================================================================================
// ?
//=============================================================================================================


HPPRdHPMA = ODIV(HPdPR// Soll dividiert werden
                 ,
                 HPdMA// Wert, durch den dividiert werden soll
                );


HPMAdHPPR = ODIV(HPdMA// Soll dividiert werden
                 ,
                 HPdPR// Wert, durch den dividiert werden soll
                );
                 

//=============================================================================================================
// ?
//=============================================================================================================




//=============================================================================================================
// B U F F E R
//=============================================================================================================


BUF_HPdPdM_fa[i] = OMUL(HPPRdHPMA// Soll multipliziert werden
                        ,
                        Perc_Fast// Wert, der kleiner als 1.0 ist
                       );


//-------------------------------------------------------------------------------------------------------------


BUF_HPdPdM_sl[i] = OMUL(HPMAdHPPR// Soll multipliziert werden
                        ,
                        Perc_Slow//
                       );

//=============================================================================================================
// O P Z   D I V
//=============================================================================================================

double ODIV(

  double ODIV_ToDiv// Soll dividiert werden
  ,
  double ODIV_Div// Wert, der kleiner als 1.0 ist
  
){
  
  double
  ODIV_DIV_mt
  ,
  ODIV_DivEd
  ,
  ODIV_DivEd_t;
  
  int ODIV_mt;
  

  if( ODIV_Div <= -1.0 || ODIV_Div >= 1.0 )ODIV_DivEd = ODIV_ToDiv / ODIV_Div;


  if( ODIV_Div > -1.0 && ODIV_Div < 1.0 ){
  
    ODIV_mt=0;
    while( ODIV_Div > -1.0 && ODIV_Div < 1.0 ){
  
      ODIV_DIV_mt = ODIV_Div * 10.0;
    
      ODIV_Div = ODIV_DIV_mt;
    
      ODIV_mt++;}
  
  
    ODIV_DivEd = ODIV_ToDiv / ODIV_DIV_mt;


    for( ODIV_mt ; ODIV_mt > 1 ; ODIV_mt-- ){
  
      ODIV_DivEd_t = ODIV_DivEd * 10.0;
    
      ODIV_DivEd = ODIV_DivEd_t;}
  
  }

  return ODIV_DivEd;

}

//=============================================================================================================
// O P Z   M U L
//=============================================================================================================

double OMUL(

  double OMUL_ToMul// Soll multipliziert werden
  ,  
  double OMUL_Mul// Wert, der kleiner als 1.0 ist

){
  
  double
  OMUL_MUL_mt
  ,
  OMUL_MulEd
  ,
  OMUL_MulEd_t;
  
  int OMUL_mt;


  if( OMUL_ToMul <= -1.0 || OMUL_ToMul >= 1.0 || OMUL_Mul <= -1.0 || OMUL_Mul >= 1.0 )OMUL_MulEd = OMUL_ToMul * OMUL_Mul;
  
  
  if( OMUL_ToMul > -1.0 && OMUL_ToMul < 1.0 && OMUL_Mul > -1.0 && OMUL_Mul < 1.0 ){

    OMUL_mt=0;
    while( OMUL_Mul > -1.0 && OMUL_Mul < 1.0 ){
  
      OMUL_MUL_mt = OMUL_Mul * 10.0;
    
      OMUL_Mul = OMUL_MUL_mt;
    
      OMUL_mt++;}
  
  
    OMUL_MulEd = OMUL_ToMul * OMUL_MUL_mt;


    for( OMUL_mt ; OMUL_mt > 1 ; OMUL_mt-- ){
  
      OMUL_MulEd_t = OMUL_MulEd / 10.0;
    
      OMUL_MulEd = OMUL_MulEd_t;}
  
  }

   return OMUL_MulEd;

 }

if( PR > -1.0 && PR <  1.0 ){

  PR_mt=PR;
  mt=-1;
  while( PR_mt > -1.0 && PR_mt < 1.0 ){
  
    PR_t = PR_mt * 10.0;
    
    PR_mt = PR_t;
    
    mt++;}

OPZ_PR = 1.0 / PR_mt;