//+------------------------------------------------------------------+
//| |
//| funtik.mq4 |
//| Copyright © 2007, sashken |
//| |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2007, sashken, sashken@mail.ru"
#property link "sashken@mail.ru"
//////////////////////////////////////////////////////////////////////
// //
// Ïðåäóïðåæäåíèå: äàííûé ñîâåòíèê ñîçäàí ñïåöèàëüíî äëÿ ×åìïèîíàòà //
// (ïîæàëóéñòà, íå èñïîëüçóéòå íà ðåàëå!!!) //
// //
// Please don't use this EA on real money (only Demo or Testing) //
// //
//////////////////////////////////////////////////////////////////////
// //
// Èñïîëüçóåòñÿ: //
// | MACD Sample (ñèãíàëû îòêðûòèÿ/çàêðûòèÿ) //
// | e-TrailingStop (Èãîðü Êèì, KimIV) //
// //
//////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////
extern double MaximumRisk = 0.15;
extern int MaxOrders = 3;
extern double MaxLots = 5;
///////////////////////////////////////////////////////////////////////
// èñïîëüçîâàòü(1) / íå èñïîëüçîâàòü(0)
extern int macd__1 = 1;
extern int macd__2 = 1;
extern int macd__3 = 1;
extern int macd__4 = 1;
extern int macd__5 = 1;
extern int macd__6 = 1;
extern int macd__7 = 1;
extern int macd__8 = 1;
extern int macd__9 = 1;
extern int macd__10 = 1;
extern int macd__11 = 1;
extern int macd__12 = 1;
///////////////////////////////////////////////////////////////////////
// MACD_1
extern double TakeProfit = 300;
extern double StopLoss = 45;
extern double TrailingStop = 5;
extern double MACDOpenLevel = 6;
extern double MACDCloseLevel = 50;
extern double MATrendPeriod = 11;
extern int MACDf = 194;
extern int MACDs = 475;
extern int MACDsig = 45;
///////////////////////////////////////////////////////////////////////
// MACD_2
extern double TakeProfit_2 = 90;
extern double StopLoss_2 = 175;
extern double TrailingStop_2 = 15;
extern double MACDOpenLevel_2 = 7;
extern double MACDCloseLevel_2 = 83;
extern double MATrendPeriod_2 = 44;
extern int MACDf_2 = 67;
extern int MACDs_2 = 316;
extern int MACDsig_2 = 39;
//////////////////////////////////////////////////////////////////////
// MACD_3
extern double TakeProfit_3 = 95;
extern double StopLoss_3 = 195;
extern double TrailingStop_3 = 100;
extern double MACDOpenLevel_3 = 14;
extern double MACDCloseLevel_3 = 87;
extern double MATrendPeriod_3 = 50;
extern int MACDf_3 = 10;
extern int MACDs_3 = 436;
extern int MACDsig_3 = 28;
//////////////////////////////////////////////////////////////////////
// MACD_4
extern double TakeProfit_4 = 50;
extern double StopLoss_4 = 95;
extern double TrailingStop_4 = 95;
extern double MACDOpenLevel_4 = 54;
extern double MACDCloseLevel_4 = 93;
extern double MATrendPeriod_4 = 65;
extern int MACDf_4 = 181;
extern int MACDs_4 = 482;
extern int MACDsig_4 = 36;
//////////////////////////////////////////////////////////////////////
// MACD_5
extern double TakeProfit_5 = 265;
extern double StopLoss_5 = 185;
extern double TrailingStop_5 = 20;
extern double MACDOpenLevel_5 = 18;
extern double MACDCloseLevel_5 = 24;
extern double MATrendPeriod_5 = 24;
extern int MACDf_5 = 27;
extern int MACDs_5 = 459;
extern int MACDsig_5 = 79;
//////////////////////////////////////////////////////////////////////
// MACD_6
extern double TakeProfit_6 = 80;
extern double StopLoss_6 = 190;
extern double TrailingStop_6 = 70;
extern double MACDOpenLevel_6 = 75;
extern double MACDCloseLevel_6 = 104;
extern double MATrendPeriod_6 = 40;
extern int MACDf_6 = 3;
extern int MACDs_6 = 260;
extern int MACDsig_6 = 40;
//////////////////////////////////////////////////////////////////////
// MACD_7
extern double TakeProfit_7 = 285;
extern double StopLoss_7 = 50;
extern double TrailingStop_7 = 10;
extern double MACDOpenLevel_7 = 102;
extern double MACDCloseLevel_7 = 86;
extern double MATrendPeriod_7 = 69;
extern int MACDf_7 = 77;
extern int MACDs_7 = 67;
extern int MACDsig_7 = 27;
//////////////////////////////////////////////////////////////////////
// MACD_8
extern double TakeProfit_8 = 25;
extern double StopLoss_8 = 145;
extern double TrailingStop_8 = 100;
extern double MACDOpenLevel_8 = 36;
extern double MACDCloseLevel_8 = 136;
extern double MATrendPeriod_8 = 1;
extern int MACDf_8 = 116;
extern int MACDs_8 = 430;
extern int MACDsig_8 = 9;
//////////////////////////////////////////////////////////////////////
// MACD_9
extern double TakeProfit_9 = 75;
extern double StopLoss_9 = 105;
extern double TrailingStop_9 = 35;
extern double MACDOpenLevel_9 = 54;
extern double MACDCloseLevel_9 = 93;
extern double MATrendPeriod_9 = 68;
extern int MACDf_9 = 181;
extern int MACDs_9 = 482;
extern int MACDsig_9 = 36;
//////////////////////////////////////////////////////////////////////
// MACD_10
extern double TakeProfit_10 = 175;
extern double StopLoss_10 = 190;
extern double TrailingStop_10 = 50;
extern double MACDOpenLevel_10 = 44;
extern double MACDCloseLevel_10 = 54;
extern double MATrendPeriod_10 = 55;
extern int MACDf_10 = 12;
extern int MACDs_10 = 26;
extern int MACDsig_10 = 9;
//////////////////////////////////////////////////////////////////////
// MACD_11
extern double TakeProfit_11 = 285;
extern double StopLoss_11 = 200;
extern double TrailingStop_11 = 40;
extern double MACDOpenLevel_11 = 121;
extern double MACDCloseLevel_11 = 64;
extern double MATrendPeriod_11 = 53;
extern int MACDf_11 = 13;
extern int MACDs_11 = 435;
extern int MACDsig_11 = 47;
//////////////////////////////////////////////////////////////////////
// MACD_12
extern double TakeProfit_12 = 75; // 10 // 75
extern double StopLoss_12 = 10; // 10 // 50
extern double TrailingStop_12 = 15; // 80 // 15
extern double MACDOpenLevel_12 = 21; // 13 // 21 // 12
extern double MACDCloseLevel_12 = 39; // 20 // 39 // 18
extern double MATrendPeriod_12 = 89;
extern int MACDf_12 = 24;
extern int MACDs_12 = 52;
extern int MACDsig_12 = 18;
///////////////////////////////////////////////////////////////////////
// Ìàãèêè
extern int Magic_1 = 1001001;
extern int Magic_2 = 1001002;
extern int Magic_3 = 1001003;
extern int Magic_4 = 1001004;
extern int Magic_5 = 1001005;
extern int Magic_6 = 1001006;
extern int Magic_7 = 1001007;
extern int Magic_8 = 1001008;
extern int Magic_9 = 1001009;
extern int Magic_10 = 1001010;
extern int Magic_11 = 1001011;
extern int Magic_12 = 1001012;
///////////////////////////////////////////////////////////////////////
// Òðàë
extern bool ProfitTrailing = True; // Òðàëèòü òîëüêî ïðîôèò
extern int TrailingStep = 7; // Øàã òðàëà
///////////////////////////////////////////////////////////////////////
// Êîë-âî ïîïûòîê îòêðûòèÿ îðäåðà ïðè ðåêâîòàõ
extern int raz = 5;
///////////////////////////////////////////////////////////////////////
//
double Lots = 0.1;
int slipage = 3;
int _prevTime = 0;
///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////
int init()
{
}
///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////
int start()
{
if (!Trade()) return(0);
int curTime = Time[0];
if (_prevTime != curTime)
{
newBar();
_prevTime = curTime;
}
newTick();
return(0);
}
int newTick()
{
for (int i=0; i<OrdersTotal(); i++)
{
if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
{
TrailingPositions();
}
}
return(0);
}
int newBar()
{
if(AccountFreeMargin()<(1000*LotSize()))
{
Print("We have no money. Free Margin = ", AccountFreeMargin());
return(0);
}
if (macd__7==1) exp7() ;
if(AccountFreeMargin()<(1000*LotSize()))
{
Print("We have no money. Free Margin = ", AccountFreeMargin());
return(0);
}
if (macd__8==1) exp8() ;
if(AccountFreeMargin()<(1000*LotSize()))
{
Print("We have no money. Free Margin = ", AccountFreeMargin());
return(0);
}
if (macd__4==1) exp4() ;
if(AccountFreeMargin()<(1000*LotSize()))
{
Print("We have no money. Free Margin = ", AccountFreeMargin());
return(0);
}
if (macd__5==1) exp5() ;
if(AccountFreeMargin()<(1000*LotSize()))
{
Print("We have no money. Free Margin = ", AccountFreeMargin());
return(0);
}
if (macd__6==1) exp6() ;
if(AccountFreeMargin()<(1000*LotSize()))
{
Print("We have no money. Free Margin = ", AccountFreeMargin());
return(0);
}
if (macd__1==1) exp1() ;
if(AccountFreeMargin()<(1000*LotSize()))
{
Print("We have no money. Free Margin = ", AccountFreeMargin());
return(0);
}
if (macd__2==1) exp2() ;
if(AccountFreeMargin()<(1000*LotSize()))
{
Print("We have no money. Free Margin = ", AccountFreeMargin());
return(0);
}
if (macd__12==1) exp12() ;
if(AccountFreeMargin()<(1000*LotSize()))
{
Print("We have no money. Free Margin = ", AccountFreeMargin());
return(0);
}
if (macd__3==1) exp3() ;
if(AccountFreeMargin()<(1000*LotSize()))
{
Print("We have no money. Free Margin = ", AccountFreeMargin());
return(0);
}
if (macd__9==1) exp9() ;
if(AccountFreeMargin()<(1000*LotSize()))
{
Print("We have no money. Free Margin = ", AccountFreeMargin());
return(0);
}
if (macd__10==1) exp10() ;
if(AccountFreeMargin()<(1000*LotSize()))
{
Print("We have no money. Free Margin = ", AccountFreeMargin());
return(0);
}
if (macd__11==1) exp11() ;
return(0);
}
///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////
int exp1()
{
double MacdCurrent, MacdPrevious, SignalCurrent;
double SignalPrevious, MaCurrent, MaPrevious;
int cnt, ticket, total;
if(Bars<100)
{
Print("bars less than 100");
return(0);
}
MacdCurrent = NormalizeDouble(iMACD(NULL,0,MACDf,MACDs,MACDsig,PRICE_CLOSE,MODE_MAIN,1),8);
MacdPrevious = NormalizeDouble(iMACD(NULL,0,MACDf,MACDs,MACDsig,PRICE_CLOSE,MODE_MAIN,2),8);
SignalCurrent = NormalizeDouble(iMACD(NULL,0,MACDf,MACDs,MACDsig,PRICE_CLOSE,MODE_SIGNAL,1),8);
SignalPrevious = NormalizeDouble(iMACD(NULL,0,MACDf,MACDs,MACDsig,PRICE_CLOSE,MODE_SIGNAL,2),8);
MaCurrent = NormalizeDouble(iMA(NULL,0,MATrendPeriod,0,MODE_EMA,PRICE_CLOSE,1),8);
MaPrevious = NormalizeDouble(iMA(NULL,0,MATrendPeriod,0,MODE_EMA,PRICE_CLOSE,2),8);
if(OrderTotalMagic(Magic_1)<1 && OrdersTotal()<MaxOrders)
{
if(MacdCurrent<0 && MacdCurrent>SignalCurrent && MacdPrevious<SignalPrevious &&
MathAbs(MacdCurrent)>(MACDOpenLevel*Point) && MaCurrent>MaPrevious)
{
OpenBuy(StopLoss, TakeProfit, Magic_1);
}
if(MacdCurrent>0 && MacdCurrent<SignalCurrent && MacdPrevious>SignalPrevious &&
MacdCurrent>(MACDOpenLevel*Point) && MaCurrent<MaPrevious)
{
OpenSell(StopLoss, TakeProfit, Magic_1);
}
return(0);
}
total=OrdersTotal();
for(cnt=0;cnt<total;cnt++)
{
OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES);
if (OrderMagicNumber()!=Magic_1) continue;
else
{
if(OrderType()<=OP_SELL && // check for opened position
OrderSymbol()==Symbol())
{
if(OrderType()==OP_BUY) // long position is opened
{
if(MacdCurrent>0 && MacdCurrent<SignalCurrent && MacdPrevious>SignalPrevious &&
MacdCurrent>(MACDCloseLevel*Point))
{
OrderClose(OrderTicket(),OrderLots(),Bid,3,Violet); // close position
return(0); // exit
}
}
else // go to short position
{
if(MacdCurrent<0 && MacdCurrent>SignalCurrent &&
MacdPrevious<SignalPrevious && MathAbs(MacdCurrent)>(MACDCloseLevel*Point))
{
OrderClose(OrderTicket(),OrderLots(),Ask,3,Violet); // close position
return(0); // exit
}
}
}
}
}
return(0);
}
///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////
int exp2()
{
double MacdCurrent, MacdPrevious, SignalCurrent;
double SignalPrevious, MaCurrent, MaPrevious;
int cnt, ticket, total;
if(Bars<100)
{
Print("bars less than 100");
return(0);
}
MacdCurrent = NormalizeDouble(iMACD(NULL,0,MACDf_2,MACDs_2,MACDsig_2,PRICE_CLOSE,MODE_MAIN,1),8);
MacdPrevious = NormalizeDouble(iMACD(NULL,0,MACDf_2,MACDs_2,MACDsig_2,PRICE_CLOSE,MODE_MAIN,2),8);
SignalCurrent = NormalizeDouble(iMACD(NULL,0,MACDf_2,MACDs_2,MACDsig_2,PRICE_CLOSE,MODE_SIGNAL,1),8);
SignalPrevious = NormalizeDouble(iMACD(NULL,0,MACDf_2,MACDs_2,MACDsig_2,PRICE_CLOSE,MODE_SIGNAL,2),8);
MaCurrent = NormalizeDouble(iMA(NULL,0,MATrendPeriod_2,0,MODE_EMA,PRICE_CLOSE,1),8);
MaPrevious = NormalizeDouble(iMA(NULL,0,MATrendPeriod_2,0,MODE_EMA,PRICE_CLOSE,2),8);
if(OrderTotalMagic(Magic_2)<1 && OrdersTotal()<MaxOrders)
{
if(MacdCurrent<0 && MacdCurrent>SignalCurrent && MacdPrevious<SignalPrevious &&
MathAbs(MacdCurrent)>(MACDOpenLevel_2*Point) && MaCurrent>MaPrevious)
{
OpenBuy(StopLoss_2, TakeProfit_2, Magic_2);
}
if(MacdCurrent>0 && MacdCurrent<SignalCurrent && MacdPrevious>SignalPrevious &&
MacdCurrent>(MACDOpenLevel_2*Point) && MaCurrent<MaPrevious)
{
OpenSell(StopLoss_2, TakeProfit_2, Magic_2);
}
return(0);
}
total=OrdersTotal();
for(cnt=0;cnt<total;cnt++)
{
OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES);
if(OrderMagicNumber()!=Magic_2) continue;
if(OrderType()<=OP_SELL && // check for opened position
OrderSymbol()==Symbol())
{
if(OrderType()==OP_BUY) // long position is opened
{
if(MacdCurrent>0 && MacdCurrent<SignalCurrent && MacdPrevious>SignalPrevious &&
MacdCurrent>(MACDCloseLevel_2*Point))
{
OrderClose(OrderTicket(),OrderLots(),Bid,3,Violet); // close position
return(0); // exit
}
}
else // go to short position
{
if(MacdCurrent<0 && MacdCurrent>SignalCurrent &&
MacdPrevious<SignalPrevious && MathAbs(MacdCurrent)>(MACDCloseLevel_2*Point))
{
OrderClose(OrderTicket(),OrderLots(),Ask,3,Violet); // close position
return(0); // exit
}
}
}
}
return(0);
}
///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////
int exp3()
{
double MacdCurrent, MacdPrevious, SignalCurrent;
double SignalPrevious, MaCurrent, MaPrevious;
int cnt, ticket, total;
if(Bars<100)
{
Print("bars less than 100");
return(0);
}
MacdCurrent = NormalizeDouble(iMACD(NULL,0,MACDf_3,MACDs_3,MACDsig_3,PRICE_CLOSE,MODE_MAIN,1),8);
MacdPrevious = NormalizeDouble(iMACD(NULL,0,MACDf_3,MACDs_3,MACDsig_3,PRICE_CLOSE,MODE_MAIN,2),8);
SignalCurrent = NormalizeDouble(iMACD(NULL,0,MACDf_3,MACDs_3,MACDsig_3,PRICE_CLOSE,MODE_SIGNAL,1),8);
SignalPrevious = NormalizeDouble(iMACD(NULL,0,MACDf_3,MACDs_3,MACDsig_3,PRICE_CLOSE,MODE_SIGNAL,2),8);
MaCurrent = NormalizeDouble(iMA(NULL,0,MATrendPeriod_3,0,MODE_EMA,PRICE_CLOSE,1),8);
MaPrevious = NormalizeDouble(iMA(NULL,0,MATrendPeriod_3,0,MODE_EMA,PRICE_CLOSE,2),8);
if(OrderTotalMagic(Magic_3)<1 && OrdersTotal()<MaxOrders)
{
if(MacdCurrent<0 && MacdCurrent>SignalCurrent && MacdPrevious<SignalPrevious &&
MathAbs(MacdCurrent)>(MACDOpenLevel_3*Point) && MaCurrent>MaPrevious)
{
OpenBuy(StopLoss_3, TakeProfit_3, Magic_3);
}
if(MacdCurrent>0 && MacdCurrent<SignalCurrent && MacdPrevious>SignalPrevious &&
MacdCurrent>(MACDOpenLevel_3*Point) && MaCurrent<MaPrevious)
{
OpenSell(StopLoss_3, TakeProfit_3, Magic_3);
}
return(0);
}
total=OrdersTotal();
for(cnt=0;cnt<total;cnt++)
{
OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES);
if(OrderMagicNumber()!=Magic_3) continue;
if(OrderType()<=OP_SELL && // check for opened position
OrderSymbol()==Symbol())
{
if(OrderType()==OP_BUY) // long position is opened
{
if(MacdCurrent>0 && MacdCurrent<SignalCurrent && MacdPrevious>SignalPrevious &&
MacdCurrent>(MACDCloseLevel_3*Point))
{
OrderClose(OrderTicket(),OrderLots(),Bid,3,Violet); // close position
return(0); // exit
}
}
else // go to short position
{
if(MacdCurrent<0 && MacdCurrent>SignalCurrent &&
MacdPrevious<SignalPrevious && MathAbs(MacdCurrent)>(MACDCloseLevel_3*Point))
{
OrderClose(OrderTicket(),OrderLots(),Ask,3,Violet); // close position
return(0); // exit
}
}
}
}
return(0);
}
///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////
int exp4()
{
double MacdCurrent, MacdPrevious, SignalCurrent;
double SignalPrevious, MaCurrent, MaPrevious;
int cnt, ticket, total;
if(Bars<100)
{
Print("bars less than 100");
return(0);
}
MacdCurrent = NormalizeDouble(iMACD(NULL,0,MACDf_4,MACDs_4,MACDsig_4,PRICE_CLOSE,MODE_MAIN,1),8);
MacdPrevious = NormalizeDouble(iMACD(NULL,0,MACDf_4,MACDs_4,MACDsig_4,PRICE_CLOSE,MODE_MAIN,2),8);
SignalCurrent = NormalizeDouble(iMACD(NULL,0,MACDf_4,MACDs_4,MACDsig_4,PRICE_CLOSE,MODE_SIGNAL,1),8);
SignalPrevious = NormalizeDouble(iMACD(NULL,0,MACDf_4,MACDs_4,MACDsig_4,PRICE_CLOSE,MODE_SIGNAL,2),8);
MaCurrent = NormalizeDouble(iMA(NULL,0,MATrendPeriod_4,0,MODE_EMA,PRICE_CLOSE,1),8);
MaPrevious = NormalizeDouble(iMA(NULL,0,MATrendPeriod_4,0,MODE_EMA,PRICE_CLOSE,2),8);
if(OrderTotalMagic(Magic_4)<1 && OrdersTotal()<MaxOrders)
{
if(MacdCurrent<0 && MacdCurrent>SignalCurrent && MacdPrevious<SignalPrevious &&
MathAbs(MacdCurrent)>(MACDOpenLevel_4*Point) && MaCurrent>MaPrevious)
{
OpenBuy(StopLoss_4, TakeProfit_4, Magic_4);
}
if(MacdCurrent>0 && MacdCurrent<SignalCurrent && MacdPrevious>SignalPrevious &&
MacdCurrent>(MACDOpenLevel_4*Point) && MaCurrent<MaPrevious)
{
OpenSell(StopLoss_4, TakeProfit_4, Magic_4);
}
return(0);
}
total=OrdersTotal();
for(cnt=0;cnt<total;cnt++)
{
OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES);
if(OrderMagicNumber()!=Magic_4) continue;
if(OrderType()<=OP_SELL && // check for opened position
OrderSymbol()==Symbol())
{
if(OrderType()==OP_BUY) // long position is opened
{
if(MacdCurrent>0 && MacdCurrent<SignalCurrent && MacdPrevious>SignalPrevious &&
MacdCurrent>(MACDCloseLevel_4*Point))
{
OrderClose(OrderTicket(),OrderLots(),Bid,3,Violet); // close position
return(0); // exit
}
}
else // go to short position
{
if(MacdCurrent<0 && MacdCurrent>SignalCurrent &&
MacdPrevious<SignalPrevious && MathAbs(MacdCurrent)>(MACDCloseLevel_4*Point))
{
OrderClose(OrderTicket(),OrderLots(),Ask,3,Violet); // close position
return(0); // exit
}
}
}
}
return(0);
}
///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////
int exp5()
{
double MacdCurrent, MacdPrevious, SignalCurrent;
double SignalPrevious, MaCurrent, MaPrevious;
int cnt, ticket, total;
if(Bars<100)
{
Print("bars less than 100");
return(0);
}
MacdCurrent = NormalizeDouble(iMACD(NULL,0,MACDf_5,MACDs_5,MACDsig_5,PRICE_CLOSE,MODE_MAIN,1),8);
MacdPrevious = NormalizeDouble(iMACD(NULL,0,MACDf_5,MACDs_5,MACDsig_5,PRICE_CLOSE,MODE_MAIN,2),8);
SignalCurrent = NormalizeDouble(iMACD(NULL,0,MACDf_5,MACDs_5,MACDsig_5,PRICE_CLOSE,MODE_SIGNAL,1),8);
SignalPrevious = NormalizeDouble(iMACD(NULL,0,MACDf_5,MACDs_5,MACDsig_5,PRICE_CLOSE,MODE_SIGNAL,2),8);
MaCurrent = NormalizeDouble(iMA(NULL,0,MATrendPeriod_5,0,MODE_EMA,PRICE_CLOSE,1),8);
MaPrevious = NormalizeDouble(iMA(NULL,0,MATrendPeriod_5,0,MODE_EMA,PRICE_CLOSE,2),8);
if(OrderTotalMagic(Magic_5)<1 && OrdersTotal()<MaxOrders)
{
if(MacdCurrent<0 && MacdCurrent>SignalCurrent && MacdPrevious<SignalPrevious &&
MathAbs(MacdCurrent)>(MACDOpenLevel_5*Point) && MaCurrent>MaPrevious)
{
OpenBuy(StopLoss_5, TakeProfit_5, Magic_5);
}
if(MacdCurrent>0 && MacdCurrent<SignalCurrent && MacdPrevious>SignalPrevious &&
MacdCurrent>(MACDOpenLevel_5*Point) && MaCurrent<MaPrevious)
{
OpenSell(StopLoss_5, TakeProfit_5, Magic_5);
}
return(0);
}
total=OrdersTotal();
for(cnt=0;cnt<total;cnt++)
{
OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES);
if(OrderMagicNumber()!=Magic_5) continue;
if(OrderType()<=OP_SELL && // check for opened position
OrderSymbol()==Symbol())
{
if(OrderType()==OP_BUY) // long position is opened
{
if(MacdCurrent>0 && MacdCurrent<SignalCurrent && MacdPrevious>SignalPrevious &&
MacdCurrent>(MACDCloseLevel_5*Point))
{
OrderClose(OrderTicket(),OrderLots(),Bid,3,Violet); // close position
return(0); // exit
}
}
else // go to short position
{
if(MacdCurrent<0 && MacdCurrent>SignalCurrent &&
MacdPrevious<SignalPrevious && MathAbs(MacdCurrent)>(MACDCloseLevel_5*Point))
{
OrderClose(OrderTicket(),OrderLots(),Ask,3,Violet); // close position
return(0); // exit
}
}
}
}
return(0);
}
///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////
int exp6()
{
double MacdCurrent, MacdPrevious, SignalCurrent;
double SignalPrevious, MaCurrent, MaPrevious;
int cnt, ticket, total;
if(Bars<100)
{
Print("bars less than 100");
return(0);
}
MacdCurrent = NormalizeDouble(iMACD(NULL,240,MACDf_6,MACDs_6,MACDsig_6,PRICE_CLOSE,MODE_MAIN,1),8);
MacdPrevious = NormalizeDouble(iMACD(NULL,240,MACDf_6,MACDs_6,MACDsig_6,PRICE_CLOSE,MODE_MAIN,2),8);
SignalCurrent = NormalizeDouble(iMACD(NULL,240,MACDf_6,MACDs_6,MACDsig_6,PRICE_CLOSE,MODE_SIGNAL,1),8);
SignalPrevious = NormalizeDouble(iMACD(NULL,240,MACDf_6,MACDs_6,MACDsig_6,PRICE_CLOSE,MODE_SIGNAL,2),8);
MaCurrent = NormalizeDouble(iMA(NULL,240,MATrendPeriod_6,0,MODE_EMA,PRICE_CLOSE,1),8);
MaPrevious = NormalizeDouble(iMA(NULL,240,MATrendPeriod_6,0,MODE_EMA,PRICE_CLOSE,2),8);
if(OrderTotalMagic(Magic_6)<1 && OrdersTotal()<MaxOrders)
{
if(MacdCurrent<0 && MacdCurrent>SignalCurrent && MacdPrevious<SignalPrevious &&
MathAbs(MacdCurrent)>(MACDOpenLevel_6*Point) && MaCurrent>MaPrevious)
{
OpenBuy(StopLoss_6, TakeProfit_6, Magic_6);
}
if(MacdCurrent>0 && MacdCurrent<SignalCurrent && MacdPrevious>SignalPrevious &&
MacdCurrent>(MACDOpenLevel_6*Point) && MaCurrent<MaPrevious)
{
OpenSell(StopLoss_6, TakeProfit_6, Magic_6);
}
return(0);
}
total=OrdersTotal();
for(cnt=0;cnt<total;cnt++)
{
OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES);
if(OrderMagicNumber()!=Magic_6) continue;
if(OrderType()<=OP_SELL && // check for opened position
OrderSymbol()==Symbol())
{
if(OrderType()==OP_BUY) // long position is opened
{
if(MacdCurrent>0 && MacdCurrent<SignalCurrent && MacdPrevious>SignalPrevious &&
MacdCurrent>(MACDCloseLevel_6*Point))
{
OrderClose(OrderTicket(),OrderLots(),Bid,3,Violet); // close position
return(0); // exit
}
}
else // go to short position
{
if(MacdCurrent<0 && MacdCurrent>SignalCurrent &&
MacdPrevious<SignalPrevious && MathAbs(MacdCurrent)>(MACDCloseLevel_6*Point))
{
OrderClose(OrderTicket(),OrderLots(),Ask,3,Violet); // close position
return(0); // exit
}
}
}
}
return(0);
}
///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////
int exp7()
{
double MacdCurrent, MacdPrevious, SignalCurrent;
double SignalPrevious, MaCurrent, MaPrevious;
int cnt, ticket, total;
if(Bars<100)
{
Print("bars less than 100");
return(0);
}
MacdCurrent = NormalizeDouble(iMACD(NULL,0,MACDf_7,MACDs_7,MACDsig_7,PRICE_CLOSE,MODE_MAIN,1),8);
MacdPrevious = NormalizeDouble(iMACD(NULL,0,MACDf_7,MACDs_7,MACDsig_7,PRICE_CLOSE,MODE_MAIN,2),8);
SignalCurrent = NormalizeDouble(iMACD(NULL,0,MACDf_7,MACDs_7,MACDsig_7,PRICE_CLOSE,MODE_SIGNAL,1),8);
SignalPrevious = NormalizeDouble(iMACD(NULL,0,MACDf_7,MACDs_7,MACDsig_7,PRICE_CLOSE,MODE_SIGNAL,2),8);
MaCurrent = NormalizeDouble(iMA(NULL,0,MATrendPeriod_7,0,MODE_EMA,PRICE_CLOSE,1),8);
MaPrevious = NormalizeDouble(iMA(NULL,0,MATrendPeriod_7,0,MODE_EMA,PRICE_CLOSE,2),8);
if(OrderTotalMagic(Magic_7)<1 && OrdersTotal()<MaxOrders)
{
if(MacdCurrent<0 && MacdCurrent>SignalCurrent && MacdPrevious<SignalPrevious &&
MathAbs(MacdCurrent)>(MACDOpenLevel_7*Point) && MaCurrent>MaPrevious)
{
OpenBuy(StopLoss_7, TakeProfit_7, Magic_7);
}
if(MacdCurrent>0 && MacdCurrent<SignalCurrent && MacdPrevious>SignalPrevious &&
MacdCurrent>(MACDOpenLevel_7*Point) && MaCurrent<MaPrevious)
{
OpenSell(StopLoss_7, TakeProfit_7, Magic_7);
}
return(0);
}
total=OrdersTotal();
for(cnt=0;cnt<total;cnt++)
{
OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES);
if(OrderMagicNumber()!=Magic_7) continue;
if(OrderType()<=OP_SELL && // check for opened position
OrderSymbol()==Symbol())
{
if(OrderType()==OP_BUY) // long position is opened
{
if(MacdCurrent>0 && MacdCurrent<SignalCurrent && MacdPrevious>SignalPrevious &&
MacdCurrent>(MACDCloseLevel_7*Point))
{
OrderClose(OrderTicket(),OrderLots(),Bid,3,Violet); // close position
return(0); // exit
}
}
else // go to short position
{
if(MacdCurrent<0 && MacdCurrent>SignalCurrent &&
MacdPrevious<SignalPrevious && MathAbs(MacdCurrent)>(MACDCloseLevel_7*Point))
{
OrderClose(OrderTicket(),OrderLots(),Ask,3,Violet); // close position
return(0); // exit
}
}
}
}
return(0);
}
///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////
int exp8()
{
double MacdCurrent, MacdPrevious, SignalCurrent;
double SignalPrevious, MaCurrent, MaPrevious;
int cnt, ticket, total;
if(Bars<100)
{
Print("bars less than 100");
return(0);
}
MacdCurrent = NormalizeDouble(iMACD(NULL,0,MACDf_8,MACDs_8,MACDsig_8,PRICE_CLOSE,MODE_MAIN,1),8);
MacdPrevious = NormalizeDouble(iMACD(NULL,0,MACDf_8,MACDs_8,MACDsig_8,PRICE_CLOSE,MODE_MAIN,2),8);
SignalCurrent = NormalizeDouble(iMACD(NULL,0,MACDf_8,MACDs_8,MACDsig_8,PRICE_CLOSE,MODE_SIGNAL,1),8);
SignalPrevious = NormalizeDouble(iMACD(NULL,0,MACDf_8,MACDs_8,MACDsig_8,PRICE_CLOSE,MODE_SIGNAL,2),8);
MaCurrent = NormalizeDouble(iMA(NULL,0,MATrendPeriod_8,0,MODE_EMA,PRICE_CLOSE,1),8);
MaPrevious = NormalizeDouble(iMA(NULL,0,MATrendPeriod_8,0,MODE_EMA,PRICE_CLOSE,2),8);
if(OrderTotalMagic(Magic_8)<1 && OrdersTotal()<MaxOrders)
{
if(MacdCurrent<0 && MacdCurrent>SignalCurrent && MacdPrevious<SignalPrevious &&
MathAbs(MacdCurrent)>(MACDOpenLevel_8*Point) && MaCurrent>MaPrevious)
{
OpenBuy(StopLoss_8, TakeProfit_8, Magic_8);
}
if(MacdCurrent>0 && MacdCurrent<SignalCurrent && MacdPrevious>SignalPrevious &&
MacdCurrent>(MACDOpenLevel_8*Point) && MaCurrent<MaPrevious)
{
OpenSell(StopLoss_8, TakeProfit_8, Magic_8);
}
return(0);
}
total=OrdersTotal();
for(cnt=0;cnt<total;cnt++)
{
OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES);
if(OrderMagicNumber()!=Magic_8) continue;
if(OrderType()<=OP_SELL && // check for opened position
OrderSymbol()==Symbol())
{
if(OrderType()==OP_BUY) // long position is opened
{
if(MacdCurrent>0 && MacdCurrent<SignalCurrent && MacdPrevious>SignalPrevious &&
MacdCurrent>(MACDCloseLevel_8*Point))
{
OrderClose(OrderTicket(),OrderLots(),Bid,3,Violet); // close position
return(0); // exit
}
}
else // go to short position
{
if(MacdCurrent<0 && MacdCurrent>SignalCurrent &&
MacdPrevious<SignalPrevious && MathAbs(MacdCurrent)>(MACDCloseLevel_8*Point))
{
OrderClose(OrderTicket(),OrderLots(),Ask,3,Violet); // close position
return(0); // exit
}
}
}
}
return(0);
}
///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////
int exp9()
{
double MacdCurrent, MacdPrevious, SignalCurrent;
double SignalPrevious, MaCurrent, MaPrevious;
int cnt, ticket, total;
if(Bars<100)
{
Print("bars less than 100");
return(0);
}
MacdCurrent = NormalizeDouble(iMACD(NULL,0,MACDf_9,MACDs_9,MACDsig_9,PRICE_CLOSE,MODE_MAIN,1),8);
MacdPrevious = NormalizeDouble(iMACD(NULL,0,MACDf_9,MACDs_9,MACDsig_9,PRICE_CLOSE,MODE_MAIN,2),8);
SignalCurrent = NormalizeDouble(iMACD(NULL,0,MACDf_9,MACDs_9,MACDsig_9,PRICE_CLOSE,MODE_SIGNAL,1),8);
SignalPrevious = NormalizeDouble(iMACD(NULL,0,MACDf_9,MACDs_9,MACDsig_9,PRICE_CLOSE,MODE_SIGNAL,2),8);
MaCurrent = NormalizeDouble(iMA(NULL,0,MATrendPeriod_9,0,MODE_EMA,PRICE_CLOSE,1),8);
MaPrevious = NormalizeDouble(iMA(NULL,0,MATrendPeriod_9,0,MODE_EMA,PRICE_CLOSE,2),8);
if(OrderTotalMagic(Magic_9)<1 && OrdersTotal()<MaxOrders)
{
if(MacdCurrent<0 && MacdCurrent>SignalCurrent && MacdPrevious<SignalPrevious &&
MathAbs(MacdCurrent)>(MACDOpenLevel_9*Point) && MaCurrent>MaPrevious)
{
OpenBuy(StopLoss_9, TakeProfit_9, Magic_9);
}
if(MacdCurrent>0 && MacdCurrent<SignalCurrent && MacdPrevious>SignalPrevious &&
MacdCurrent>(MACDOpenLevel_9*Point) && MaCurrent<MaPrevious)
{
OpenSell(StopLoss_9, TakeProfit_9, Magic_9);
}
return(0);
}
total=OrdersTotal();
for(cnt=0;cnt<total;cnt++)
{
OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES);
if(OrderMagicNumber()!=Magic_9) continue;
if(OrderType()<=OP_SELL && // check for opened position
OrderSymbol()==Symbol())
{
if(OrderType()==OP_BUY) // long position is opened
{
if(MacdCurrent>0 && MacdCurrent<SignalCurrent && MacdPrevious>SignalPrevious &&
MacdCurrent>(MACDCloseLevel_9*Point))
{
OrderClose(OrderTicket(),OrderLots(),Bid,3,Violet); // close position
return(0); // exit
}
}
else // go to short position
{
if(MacdCurrent<0 && MacdCurrent>SignalCurrent &&
MacdPrevious<SignalPrevious && MathAbs(MacdCurrent)>(MACDCloseLevel_9*Point))
{
OrderClose(OrderTicket(),OrderLots(),Ask,3,Violet); // close position
return(0); // exit
}
}
}
}
return(0);
}
///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////
int exp10()
{
double MacdCurrent, MacdPrevious, SignalCurrent;
double SignalPrevious, MaCurrent, MaPrevious;
int cnt, ticket, total;
if(Bars<100)
{
Print("bars less than 100");
return(0);
}
MacdCurrent = NormalizeDouble(iMACD(NULL,0,MACDf_10,MACDs_10,MACDsig_10,PRICE_CLOSE,MODE_MAIN,1),8);
MacdPrevious = NormalizeDouble(iMACD(NULL,0,MACDf_10,MACDs_10,MACDsig_10,PRICE_CLOSE,MODE_MAIN,2),8);
SignalCurrent = NormalizeDouble(iMACD(NULL,0,MACDf_10,MACDs_10,MACDsig_10,PRICE_CLOSE,MODE_SIGNAL,1),8);
SignalPrevious = NormalizeDouble(iMACD(NULL,0,MACDf_10,MACDs_10,MACDsig_10,PRICE_CLOSE,MODE_SIGNAL,2),8);
MaCurrent = NormalizeDouble(iMA(NULL,0,MATrendPeriod_10,0,MODE_EMA,PRICE_CLOSE,1),8);
MaPrevious = NormalizeDouble(iMA(NULL,0,MATrendPeriod_10,0,MODE_EMA,PRICE_CLOSE,2),8);
if(OrderTotalMagic(Magic_10)<1 && OrdersTotal()<MaxOrders)
{
if(MacdCurrent<0 && MacdCurrent>SignalCurrent && MacdPrevious<SignalPrevious &&
MathAbs(MacdCurrent)>(MACDOpenLevel_10*Point) && MaCurrent>MaPrevious)
{
OpenBuy(StopLoss_10, TakeProfit_10, Magic_10);
}
if(MacdCurrent>0 && MacdCurrent<SignalCurrent && MacdPrevious>SignalPrevious &&
MacdCurrent>(MACDOpenLevel_10*Point) && MaCurrent<MaPrevious)
{
OpenSell(StopLoss_10, TakeProfit_10, Magic_10);
}
return(0);
}
total=OrdersTotal();
for(cnt=0;cnt<total;cnt++)
{
OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES);
if(OrderMagicNumber()!=Magic_10) continue;
if(OrderType()<=OP_SELL && // check for opened position
OrderSymbol()==Symbol())
{
if(OrderType()==OP_BUY) // long position is opened
{
if(MacdCurrent>0 && MacdCurrent<SignalCurrent && MacdPrevious>SignalPrevious &&
MacdCurrent>(MACDCloseLevel_10*Point))
{
OrderClose(OrderTicket(),OrderLots(),Bid,3,Violet); // close position
return(0); // exit
}
}
else // go to short position
{
if(MacdCurrent<0 && MacdCurrent>SignalCurrent &&
MacdPrevious<SignalPrevious && MathAbs(MacdCurrent)>(MACDCloseLevel_10*Point))
{
OrderClose(OrderTicket(),OrderLots(),Ask,3,Violet); // close position
return(0); // exit
}
}
}
}
return(0);
}
///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////
int exp11()
{
double MacdCurrent, MacdPrevious, SignalCurrent;
double SignalPrevious, MaCurrent, MaPrevious;
int cnt, ticket, total;
if(Bars<100)
{
Print("bars less than 100");
return(0);
}
MacdCurrent = NormalizeDouble(iMACD(NULL,0,MACDf_11,MACDs_11,MACDsig_11,PRICE_CLOSE,MODE_MAIN,1),8);
MacdPrevious = NormalizeDouble(iMACD(NULL,0,MACDf_11,MACDs_11,MACDsig_11,PRICE_CLOSE,MODE_MAIN,2),8);
SignalCurrent = NormalizeDouble(iMACD(NULL,0,MACDf_11,MACDs_11,MACDsig_11,PRICE_CLOSE,MODE_SIGNAL,1),8);
SignalPrevious = NormalizeDouble(iMACD(NULL,0,MACDf_11,MACDs_11,MACDsig_11,PRICE_CLOSE,MODE_SIGNAL,2),8);
MaCurrent = NormalizeDouble(iMA(NULL,0,MATrendPeriod_11,0,MODE_EMA,PRICE_CLOSE,1),8);
MaPrevious = NormalizeDouble(iMA(NULL,0,MATrendPeriod_11,0,MODE_EMA,PRICE_CLOSE,2),8);
if(OrderTotalMagic(Magic_11)<1 && OrdersTotal()<MaxOrders)
{
if(MacdCurrent<0 && MacdCurrent>SignalCurrent && MacdPrevious<SignalPrevious &&
MathAbs(MacdCurrent)>(MACDOpenLevel_11*Point) && MaCurrent>MaPrevious)
{
OpenBuy(StopLoss_11, TakeProfit_11, Magic_11);
}
if(MacdCurrent>0 && MacdCurrent<SignalCurrent && MacdPrevious>SignalPrevious &&
MacdCurrent>(MACDOpenLevel_11*Point) && MaCurrent<MaPrevious)
{
OpenSell(StopLoss_11, TakeProfit_11, Magic_11);
}
return(0);
}
total=OrdersTotal();
for(cnt=0;cnt<total;cnt++)
{
OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES);
if(OrderMagicNumber()!=Magic_11) continue;
if(OrderType()<=OP_SELL && // check for opened position
OrderSymbol()==Symbol())
{
if(OrderType()==OP_BUY) // long position is opened
{
if(MacdCurrent>0 && MacdCurrent<SignalCurrent && MacdPrevious>SignalPrevious &&
MacdCurrent>(MACDCloseLevel_11*Point))
{
OrderClose(OrderTicket(),OrderLots(),Bid,3,Violet); // close position
return(0); // exit
}
}
else // go to short position
{
if(MacdCurrent<0 && MacdCurrent>SignalCurrent &&
MacdPrevious<SignalPrevious && MathAbs(MacdCurrent)>(MACDCloseLevel_11*Point))
{
OrderClose(OrderTicket(),OrderLots(),Ask,3,Violet); // close position
return(0); // exit
}
}
}
}
return(0);
}
///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////
int exp12()
{
double MacdCurrent, MacdPrevious, SignalCurrent;
double SignalPrevious, MaCurrent, MaPrevious;
int cnt, ticket, total;
if(Bars<100)
{
Print("bars less than 100");
return(0);
}
MacdCurrent = NormalizeDouble(iMACD(NULL,0,MACDf_12,MACDs_12,MACDsig_12,PRICE_CLOSE,MODE_MAIN,1),8);
MacdPrevious = NormalizeDouble(iMACD(NULL,0,MACDf_12,MACDs_12,MACDsig_12,PRICE_CLOSE,MODE_MAIN,2),8);
SignalCurrent = NormalizeDouble(iMACD(NULL,0,MACDf_12,MACDs_12,MACDsig_12,PRICE_CLOSE,MODE_SIGNAL,1),8);
SignalPrevious = NormalizeDouble(iMACD(NULL,0,MACDf_12,MACDs_12,MACDsig_12,PRICE_CLOSE,MODE_SIGNAL,2),8);
MaCurrent = NormalizeDouble(iMA(NULL,0,MATrendPeriod_12,0,MODE_EMA,PRICE_CLOSE,1),8);
MaPrevious = NormalizeDouble(iMA(NULL,0,MATrendPeriod_12,0,MODE_EMA,PRICE_CLOSE,2),8);
if(OrderTotalMagic(Magic_12)<1 && OrdersTotal()<MaxOrders)
{
if(MacdCurrent<0 && MacdCurrent>SignalCurrent && MacdPrevious<SignalPrevious &&
MathAbs(MacdCurrent)>(MACDOpenLevel_12*Point) && MaCurrent>MaPrevious)
{
OpenBuy(StopLoss_12, TakeProfit_12, Magic_12);
}
if(MacdCurrent>0 && MacdCurrent<SignalCurrent && MacdPrevious>SignalPrevious &&
MacdCurrent>(MACDOpenLevel_12*Point) && MaCurrent<MaPrevious)
{
OpenSell(StopLoss_12, TakeProfit_12, Magic_12);
}
return(0);
}
total=OrdersTotal();
for(cnt=0;cnt<total;cnt++)
{
OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES);
if(OrderMagicNumber()!=Magic_12) continue;
if(OrderType()<=OP_SELL && // check for opened position
OrderSymbol()==Symbol())
{
if(OrderType()==OP_BUY) // long position is opened
{
if(MacdCurrent>0 && MacdCurrent<SignalCurrent && MacdPrevious>SignalPrevious &&
MacdCurrent>(MACDCloseLevel_12*Point))
{
OrderClose(OrderTicket(),OrderLots(),Bid,3,Violet); // close position
return(0); // exit
}
}
else // go to short position
{
if(MacdCurrent<0 && MacdCurrent>SignalCurrent &&
MacdPrevious<SignalPrevious && MathAbs(MacdCurrent)>(MACDCloseLevel_12*Point))
{
OrderClose(OrderTicket(),OrderLots(),Ask,3,Violet); // close position
return(0); // exit
}
}
}
}
return(0);
}
///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////
int OrderTotalMagic (int magicN)
{
int kolvo=0, cnt;
int total=OrdersTotal();
for(cnt=0;cnt<total;cnt++)
{
OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES);
if(OrderType()<=OP_SELL && OrderSymbol()==Symbol() && OrderMagicNumber()==magicN)
{kolvo++;}
}
return (kolvo);
}
///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////
//+------------------------------------------------------------------+
//| Ñîïðîâîæäåíèå ïîçèöèè ïðîñòûì òðàëîì |
//+------------------------------------------------------------------+
void TrailingPositions() {
double pBid, pAsk, pp, TS;
if(OrderMagicNumber()==Magic_1) TS=TrailingStop;
if(OrderMagicNumber()==Magic_2) TS=TrailingStop_2;
if(OrderMagicNumber()==Magic_3) TS=TrailingStop_3;
if(OrderMagicNumber()==Magic_4) TS=TrailingStop_4;
if(OrderMagicNumber()==Magic_5) TS=TrailingStop_5;
if(OrderMagicNumber()==Magic_6) TS=TrailingStop_6;
if(OrderMagicNumber()==Magic_7) TS=TrailingStop_7;
if(OrderMagicNumber()==Magic_8) TS=TrailingStop_8;
if(OrderMagicNumber()==Magic_9) TS=TrailingStop_9;
if(OrderMagicNumber()==Magic_10) TS=TrailingStop_10;
if(OrderMagicNumber()==Magic_11) TS=TrailingStop_11;
if(OrderMagicNumber()==Magic_12) TS=TrailingStop_12;
if(TS<5) return;
pp = MarketInfo(OrderSymbol(), MODE_POINT);
if (OrderType()==OP_BUY) {
pBid = MarketInfo(OrderSymbol(), MODE_BID);
if (!ProfitTrailing || ND((Bid-OrderOpenPrice()))>ND(TS*pp)) {
if (ND(OrderStopLoss())<ND(Bid-(TS+TrailingStep-1)*pp) || ND(OrderStopLoss())==0) {
ModifyStopLoss(ND(Bid-TS*pp));
return;
}
}
}
if (OrderType()==OP_SELL) {
pAsk = MarketInfo(OrderSymbol(), MODE_ASK);
if (!ProfitTrailing || ND(OrderOpenPrice()-Ask)>ND(TS*pp)) {
if (ND(OrderStopLoss())>ND(Ask+(TS+TrailingStep-1)*pp) || ND(OrderStopLoss())==0) {
ModifyStopLoss(ND(Ask+TS*pp));
return;
}
}
}
}
//+------------------------------------------------------------------+
//| Ïåðåíîñ óðîâíÿ StopLoss |
//| Ïàðàìåòðû: |
//| ldStopLoss - óðîâåíü StopLoss |
//+------------------------------------------------------------------+
void ModifyStopLoss(double ldStopLoss) {
bool fm;
fm=OrderModify(OrderTicket(),ND(OrderOpenPrice()),ND(ldStopLoss),ND(OrderTakeProfit()),0,CLR_NONE);
if (!fm) Print("Error OrderModify : ",GetLastError());
}
//+------------------------------------------------------------------+
///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////
double LotSize()
{
double lot_min = MarketInfo( Symbol(), MODE_MINLOT );
double lot_max = MarketInfo( Symbol(), MODE_MAXLOT );
double lot_step = MarketInfo( Symbol(), MODE_LOTSTEP );
double freemargin = AccountFreeMargin();
int leverage = AccountLeverage();
int lotsize = MarketInfo( Symbol(), MODE_LOTSIZE );
if( lot_max > MaxLots) {lot_max=MaxLots;}
if( lot_min < 0 || lot_max <= 0.0 || lot_step <= 0.0 || lotsize <= 0 )
{
Print( "LotSize: invalid MarketInfo() results [", lot_min, ",", lot_max, ",", lot_step, ",", lotsize, "]" );
return(-1);
}
if( leverage <= 0 )
{
Print( "LotSize: invalid AccountLeverage() [", leverage, "]" );
return(-1);
}
double lot = NormalizeDouble( freemargin * MaximumRisk / leverage / 10.0, 2 );
lot = NormalizeDouble( lot / lot_step, 0 ) * lot_step;
if ( lot < lot_min ) lot = lot_min;
if ( lot > lot_max ) lot = lot_max;
double needmargin = NormalizeDouble( lotsize / leverage * Ask * lot, 2 );
if ( freemargin < needmargin )
{
Print( "LotSize: We have no money. Free Margin = ", freemargin );
return(-1);
}
return(lot);
}
///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////
double ND (double NormDouble)
{
double NDB = NormalizeDouble (NormDouble, Digits);
return (NDB);
}
///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////
bool Trade()
{
if (IsConnected() && IsTradeAllowed()) {return (true);}
else {return (false);}
}
///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////
//--------------------------------------------ÎÒÊÐÛÂÀÅÌ BUY-----------------
void OpenBuy(int Stop, int Take, int magicN)
{
double lots=LotSize(); if (lots==0) return;
double loss=0; if (Stop>0) loss=NormalizeDouble(Ask-Stop*Point, Digits);
double profit=0; if (Take>0) profit=NormalizeDouble(Ask+Take*Point, Digits);
for (int j=0;j<raz;j++)
{
if (OrderSend(Symbol(),OP_BUY,lots,Ask,slipage,loss,profit,"funtik",magicN,0,Green)<0)
{
Print("Error opening BUY order : ",GetLastError());
if (GetLastError()==138)
{
Sleep(15000);
RefreshRates();
continue;
}
}
break;
}
}
//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
//-------------------------------------------ÎÒÊÐÛÂÀÅÌ SELL-----------------
void OpenSell(int Stop, int Take, int magicN)
{
double lots=LotSize(); if (lots==0) return;
double loss=0; if (Stop>0) loss=NormalizeDouble(Bid+Stop*Point, Digits);
double profit=0; if (Take>0) profit=NormalizeDouble(Bid-Take*Point, Digits);
for (int j=0;j<raz;j++)
{
if (OrderSend(Symbol(),OP_SELL,lots,Bid,slipage,loss,profit,"funtik",magicN,0,Red)<0)
{
Print("Error opening BUY order : ",GetLastError());
if (GetLastError()==138)
{
Sleep(15000);
RefreshRates();
continue;
}
}
break;
}
}
//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
///////////////////// ÊÎÍÅÖ /////////////////////////
Sample
Analysis
Market Information Used:
Series array that contains open time of each bar
Indicator Curves created:
Indicators Used:
MACD Histogram
Moving average indicator
Custom Indicators Used:
Order Management characteristics:
Checks for the total of open orders
It Closes Orders by itself
It can change open orders parameters, due to possible stepping strategy
It automatically opens orders when conditions are reached
Other Features:
