/*-----------------------------+
| |
| Shared by www.Aptrafx.com |
| |
+------------------------------*/
//+------------------------------------------------------------------+
//| Mouteki EA 0.4 Modifié.mq4 |
//| Copyright © 2006, GwadaTradeBoy |
//| http://www.metaquotes.net |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2006, GwadaTradeBoy"
#property link "http://www.metaquotes.net"
//-- Variables pour l'EA Mouteki --//
//#define MAGICMA 20050610
extern string nameEA = "Mouteki";
extern bool AlertsOn=True;
extern bool MultiPositions=False;
extern int ProfitToMoveSL=40;
extern int PositiveSL=10;
extern int SL_Offset=0;
extern int TP_Offset=0;
//extern double LotsPerTrade=1;
//extern bool LondonOpen=True;
//extern bool NewYorkOpen=True;
//extern bool TokyoOpen=True;
int spread;
bool TD=False;/*Default is False. True setting draws up and down arrows instead of dots on TD Points creating more clutter.*/
int BackSteps=0;/*Used to be extern int now just int. Leave at 0*/
int ShowingSteps=1;/*Used to be extern int now just int. Leave at 1*/
bool FractalAsTD=False;/*Used to be extern bool now just bool. Leave at False, otherwise Trend Lines based on Fractal Points not TD Points*/
double TrendLineBreakUp=-1;//Line added.
double TrendLineBreakUpPrev=-1;//Line added.
double TrendLineBreakUpPrev1=-1;//Line added.
bool TrendLineBreakUpFlag=False;//Line added.
double TrendLineBreakDown=-1;//Line added.
double TrendLineBreakDownPrev=-1;//Line added.
double TrendLineBreakDownPrev1=-1;//Line added.
bool TrendLineBreakDownFlag=False;//Line added.
bool BothTLBroken=False;
//---- buffers
double highs[100000];
double lows[100000];
//-- Variables pour l'indic Mouteki --//
extern bool Comments=true;/*Optional Comments. Default is false. Orginal variable called "Commen"*/
extern bool TrendLine=True;/*Default is true to draw current TD Lines*/
extern int TrendLineStyle=STYLE_SOLID;/*STYLE>_SOLID=0,DASH=1,_DOT=2,_DASHDOT=3,_DASHDDOTDOT=4. Line of code added from original.*/
extern int TrendLineWidth=1;/*Thinnest or allow dots and dashes = 0 or 1, Thinner=2, Medium=3,Thicker=4,Thickest=5. Line of code added from original.*/
extern color UpperTrendLineColour=LimeGreen;/*Line of code added from original.*/
extern color LowerTrendLineColour=Red;/*Line of code added from original.*/
extern bool ProjectionLines=True;/*Default is True. These are the TD Price Projections. Original variable called "Take Prof"*/
extern int ProjectionLinesStyle=STYLE_DOT;/*STYLE>_SOLID=0,DASH=1,_DOT=2,_DASHDOT=3,_DASHDDOTDOT=4. Line of code added from original.*/
extern int ProjectionLinesWidth=1;/*Thinnest or allow dots and dashes = 0 or 1, Thinner=2, Medium=3,Thicker=4,Thickest=5. Line of code added from original.*/
extern color UpperProjectionLineColour=LimeGreen;/*Line of code added from original.*/
extern color LowerProjectionLineColour=Red;/*Line of code added from original.*/
extern bool HorizontLine=true;/*Default is false. It seems the Horizontal Lines are were the code predicts price may cross TD line.*/
string Comm="";
//-- Variables pour l'optimisation des lots --//
extern double Lots = 0.1;
extern double MaximumRisk = 0.02;
extern double DecreaseFactor = 3;
//-- Variable pour l'optimisation de l'EA --//
bool isBuying = false;
bool isSelling = false;
bool isClosing = false;
//-- Variables pour le Signal 2 Stolastic --//
//+------------------------------------------------------------------+
//| Fonction d'initialisation de l'expert |
//+------------------------------------------------------------------+
int init()
{
//-- Lecture du spread
spread = MarketInfo(Symbol(),MODE_SPREAD);
//-- Initialisation indicateur Mouteki
SetIndexStyle(0,DRAW_ARROW);
SetIndexArrow(0,217);
SetIndexBuffer(0,highs);
SetIndexEmptyValue(0,0.0);
SetIndexStyle(1,DRAW_ARROW);
SetIndexArrow(1,218);
SetIndexBuffer(1,lows);
SetIndexEmptyValue(1,0.0);
for (int i=1;i<=10;i++)
{
ObjectDelete("HHL_"+i);ObjectDelete("HL_"+i);
ObjectDelete("HLL_"+i);ObjectDelete("LL_"+i);
ObjectDelete("HC1_"+i);
ObjectDelete("HC2_"+i);
ObjectDelete("HC3_"+i);
ObjectDelete("LC1_"+i);
ObjectDelete("LC2_"+i);
ObjectDelete("LC3_"+i);
}
Comment("");
//----
return(0);
}
//+------------------------------------------------------------------+
//| Fonction de desinitialisation de l'expert |
//+------------------------------------------------------------------+
int deinit()
{
//-- Desinitialisation indicateur Mouteki
for (int i=1;i<=10;i++)
{
ObjectDelete("HHL_"+i);ObjectDelete("HL_"+i);
ObjectDelete("HLL_"+i);ObjectDelete("LL_"+i);
ObjectDelete("HC1_"+i);
ObjectDelete("HC2_"+i);
ObjectDelete("HC3_"+i);
ObjectDelete("LC1_"+i);
ObjectDelete("LC2_"+i);
ObjectDelete("LC3_"+i);
}
Comment("");
//----
return(0);
}
//+------------------------------------------------------------------+
//| Calculs preliminaires de l'expert |
//+------------------------------------------------------------------+
//--- Calcul de la taille optimale du lot ---//
double LotsOptimized()
{
double lot=Lots;
int orders=HistoryTotal(); // Historique des ordres
int losses=0; // Nombre de trade perdants consécutif
/* Selection de la taille du lot */
lot=NormalizeDouble(AccountFreeMargin()*MaximumRisk/1000,1);
/* Calcul du nombre de perte consecutive */
if(DecreaseFactor>0)
{
for(int i=orders-1;i>=0;i--)
{
if(OrderSelect(i,SELECT_BY_POS,MODE_HISTORY)==False) { Print("Erreur dans l historique!"); break; }
if(OrderSymbol()!=Symbol() || OrderType()>OP_SELL) continue;
//----
if(OrderProfit()>0) break;
if(OrderProfit()<0) losses++;
}
if(losses>1) lot=NormalizeDouble(lot-lot*losses/DecreaseFactor,1);
}
/* Retour de la taille du lot */
if(lot<0.1) lot=0.1;
return(lot);
}
//--- Calcul préliminaire à l'utilisation de Mouteki ---//
/* Recherche des Hauts et des Bas dans le graph */
int SetTDPoint(int B)
{
int shift;
if (FractalAsTD==False)
{
for (shift=B;shift>2;shift--)
{
/* Si le Haut de la barre de gauche et egale au Haut de la barre courante, le Haut de la barre courante est un Haut valide */
if (High[shift+2]<=High[shift] && High[shift+1]<=High[shift] &&
High[shift-1]<High[shift] && High[shift-2]<High[shift])
highs[shift]=High[shift];
//if(shift<100 && highs[shift]!=0) Print("shift=", shift, " highs[shift]=", highs[shift]);
//else highs[shift]=0;
/* Si le Bas de la barre de gauche et egale au Bas de la barre courante, le Bas de la barre courante est un Bas valide */
if (Low[shift+2]>=Low[shift] && Low[shift+1]>=Low[shift] &&
Low[shift-1]>Low[shift] && Low[shift-2]>Low[shift])
lows[shift]=Low[shift];
//else lows[shift]=0;
}
highs[0]=0;
lows[0]=0;
highs[1]=0;
lows[1]=0;
}
else
{
for (shift=B;shift>3;shift--)
{
if (High[shift+1]<=High[shift] && High[shift-1]<High[shift] &&
High[shift+2]<=High[shift] && High[shift-2]<High[shift])
highs[shift]=High[shift];
else
highs[shift]=0;
if (Low[shift+1]>=Low[shift] && Low[shift-1]>Low[shift] &&
Low[shift+2]>=Low[shift] && Low[shift-2]>Low[shift])
lows[shift]=Low[shift];
else
lows[shift]=0;
}
highs[0]=0;
lows[0]=0;
highs[1]=0;
lows[1]=0;
highs[2]=0;
lows[2]=0;
}
return(0);
}
//-- Choix des sommets pour tracer la TrendLine --//
/* Sommet Haut 1 */
int GetHighTD(int P)
{
int i=0,j=0;
while (j<P)
{
i++;
while(highs[i]==0)
{
i++;if(i>Bars-2)return(-1);
}
j++;
}
return (i);
}
/* Sommet Haut 2 */
int GetNextHighTD(int P)
{
int i=P+1;
while(lows[i]<=High[P])
{
i++;if(i>Bars-2)return(-1);
}
return (i);
}
/* Sommet Bas 1 */
int GetLowTD(int P)
{
int i=0,j=0;
while (j<P)
{
i++;
while(lows[i]==0)
{
i++;if(i>Bars-2)return(-1);
}
j++;
}
return (i);
}
/* Sommet Bas 2 */
int GetNextLowTD(int P)
{
int i=P+1;
while(lows[i]>=Low[P] || lows[i]==0)
{
i++;if(i>Bars-2)return(-1);
}
return (i);
}
//-- Dessin des Trend Lines
//-- Trend Line du Haut
int TrendLineHighTD(int H1,int H2,int Step,int Col)
{
ObjectSet("HL_"+Step,OBJPROP_TIME1,Time[H2]);
ObjectSet("HL_"+Step,OBJPROP_TIME2,Time[H1]);
ObjectSet("HL_"+Step,OBJPROP_PRICE1,High[H2]);
ObjectSet("HL_"+Step,OBJPROP_PRICE2,High[H1]);
ObjectSet("HL_"+Step,OBJPROP_COLOR,UpperTrendLineColour);/*TEMP Original OBJPROP_COLOR,Col*/
if (Step==1)
ObjectSet("HL_"+Step,OBJPROP_WIDTH,TrendLineWidth);/*Original OBJPROP_WIDTH,2*/
else
ObjectSet("HL_"+Step,OBJPROP_WIDTH,1);
return(0);
}
//-- Trend Line du Bas
int TrendLineLowTD(int L1,int L2,int Step,int Col)/*Draw Lower Trend Line*/
{
ObjectSet("LL_"+Step,OBJPROP_TIME1,Time[L2]);
ObjectSet("LL_"+Step,OBJPROP_TIME2,Time[L1]);
ObjectSet("LL_"+Step,OBJPROP_PRICE1,Low[L2]);
ObjectSet("LL_"+Step,OBJPROP_PRICE2,Low[L1]);
ObjectSet("LL_"+Step,OBJPROP_COLOR,LowerTrendLineColour);/*TEMP Original OBJPROP_COLOR,Col*/
if (Step==1)
ObjectSet("LL_"+Step,OBJPROP_WIDTH,TrendLineWidth);/*Original OBJPROP_WIDTH,2*/
else
ObjectSet("LL_"+Step,OBJPROP_WIDTH,1);
return(0);
}
//-- Dessin des Projections de Prix
//-- Projection Long
string TakeProfitHighTD(int H1,int H2,int Step,int Col)/*Draw Buy TD Price Projection(s)*/
{
int i,ii,j=0;
string Comm="";
double kH,HC1,HC2,HC3,k,St;
kH=(High[H2]-High[H1])/(H2-H1);
while (NormalizeDouble(Point,j)==0)j++;
k=0;
for(i=H1;i>0;i--)
if(Close[i]>High[H2]-kH*(H2-i)){k=High[H2]-kH*(H2-i);
break;}
if (k>0)
{
Comm=Comm+"UTD_Line ("+DoubleToStr(High[H2]-kH*H2,j)+") broken at "+DoubleToStr(k,j)+", uptargets:\n";
ii=Lowest(NULL,0,MODE_LOW,H2-i,i);
HC1=High[H2]-kH*(H2-ii)-Low[ii];
HC2=High[H2]-kH*(H2-ii)-Close[ii];
ii=Lowest(NULL,0,MODE_CLOSE,H2-i,i);
HC3=High[H2]-kH*(H2-ii)-Close[ii];
St=TrendLineStyle;/*Original STYLE_SOLID*/
}
else
{
k=High[H2]-kH*H2;
Comm=Comm+"UTD_Line ("+DoubleToStr(k,j)+"), probable break-up targets:\n";
ii=Lowest(NULL,0,MODE_LOW,H2,0);
HC1=High[H2]-kH*(H2-ii)-Low[ii];
HC2=High[H2]-kH*(H2-ii)-Close[ii];
ii=Lowest(NULL,0,MODE_CLOSE,H2,0);
HC3=High[H2]-kH*(H2-ii)-Close[ii];
St=TrendLineStyle;/*Original STYLE_DASHDOT*/
}
ObjectSet("HL_"+Step,OBJPROP_STYLE,St);
Comm=Comm+"T1="+DoubleToStr(HC1+k,j)+" ("+DoubleToStr(HC1/Point,0)+"pts.)\n";//changed "pts.)" to "pts.)\n"
ObjectSet("HC1_"+Step,OBJPROP_TIME1,Time[H1]);ObjectSet("HC1_"+Step,OBJPROP_TIME2,Time[0]);
ObjectSet("HC1_"+Step,OBJPROP_PRICE1,HC1+k);ObjectSet("HC1_"+Step,OBJPROP_PRICE2,HC1+k);
ObjectSet("HC1_"+Step,OBJPROP_COLOR,Col);ObjectSet("HC1_"+Step,OBJPROP_STYLE,St);
if (Step==1)
{
ObjectSet("HC1_"+Step,OBJPROP_WIDTH,ProjectionLinesWidth);/*Original OBJPROP_WIDTH,2*/
ObjectSet("HC1_"+Step,OBJPROP_STYLE,ProjectionLinesStyle);/*This Line of code added from original. TD Upper Projection Line Style*/
}
else
{
ObjectSet("HC1_"+Step,OBJPROP_WIDTH,2);
}
return(Comm);
}
//-- Projection Short
string TakeProfitLowTD(int L1,int L2,int Step,int Col)/*Draw Sell TD Price Projection(s)*/
{
int i,ii,j=0;
string Comm="";
double kL,LC1,LC2,LC3,k,St;
kL=(Low[L1]-Low[L2])/(L2-L1);
while (NormalizeDouble(Point,j)==0)j++;
k=0;
for(i=L1;i>0;i--)
if(Close[i]<Low[L2]+kL*(L2-i))
{k=Low[L2]+kL*(L2-i);
break;}
if (k>0)
{
Comm=Comm+"LTD_Line ("+DoubleToStr(Low[L2]+kL*L2,j)+") broken at "+DoubleToStr(k,j)+", downtargets:\n";
ii=Highest(NULL,0,MODE_HIGH,L2-i,i);
LC1=High[ii]-(Low[L2]+kL*(L2-ii));
LC2=Close[ii]-(Low[L2]+kL*(L2-ii));
i=Highest(NULL,0,MODE_CLOSE,L2-i,i);
LC3=Close[ii]-(Low[L2]+kL*(L2-ii));
St=TrendLineStyle;/*Original STYLE_SOLID*/
}
else
{
k=Low[L2]+kL*L2;
Comm=Comm+"LTD_Line ("+DoubleToStr(k,j)+"), probable downbreak targets:\n";
ii=Highest(NULL,0,MODE_HIGH,L2,0);
LC1=High[ii]-(Low[L2]+kL*(L2-ii));
LC2=Close[ii]-(Low[L2]+kL*(L2-ii));
ii=Highest(NULL,0,MODE_CLOSE,L2,0);
LC3=Close[ii]-(Low[L2]+kL*(L2-ii));
St=TrendLineStyle;/*Original STYLE_DASHDOT*/
}
ObjectSet("LL_"+Step,OBJPROP_STYLE,St);
Comm=Comm+"T1="+DoubleToStr(k-LC1,j)+" ("+DoubleToStr(LC1/Point,0)+"pts.)\n";//changed "pts.)" to "pts.)\n"
ObjectSet("LC1_"+Step,OBJPROP_TIME1,Time[L1]);ObjectSet("LC1_"+Step,OBJPROP_TIME2,Time[0]);
ObjectSet("LC1_"+Step,OBJPROP_PRICE1,k-LC1);ObjectSet("LC1_"+Step,OBJPROP_PRICE2,k-LC1);
ObjectSet("LC1_"+Step,OBJPROP_COLOR,Col);ObjectSet("LC1_"+Step,OBJPROP_STYLE,St);
if (Step==1)
{
ObjectSet("LC1_"+Step,OBJPROP_WIDTH,ProjectionLinesWidth);/*Original OBJPROP_WIDTH,2*/
ObjectSet("LC1_"+Step,OBJPROP_STYLE,ProjectionLinesStyle);/*This Line of code added from original. TD Lower Projection Line Style*/
}
else
{
ObjectSet("LC1_"+Step,OBJPROP_WIDTH,2);
}
return(Comm);
}
string TDMain(int Step)
{
int H1,H2,L1,L2;
// string Comm="--- step "+Step+" --------------------\n";
int i,j; while (NormalizeDouble(Point,j)==0)j++;
double Style;
double Col[20];Col[0]=UpperProjectionLineColour/*Original Col[0]=Red, Colour for Current Upper TD Projection*/;Col[2]=Magenta;Col[4]=Chocolate;Col[6]=Goldenrod;Col[8]=SlateBlue;
Col[1]=LowerProjectionLineColour/*Original Col[1]=Blue, Colour for Current Lower TD Projection*/;Col[3]=FireBrick;Col[5]=Green;Col[7]=MediumOrchid;Col[9]=CornflowerBlue;
Col[10]=Red;Col[12]=Magenta;Col[14]=Chocolate;Col[16]=Goldenrod;Col[18]=SlateBlue;
Col[11]=Blue;Col[13]=FireBrick;Col[15]=Green;Col[17]=MediumOrchid;Col[19]=CornflowerBlue;
Step=Step+BackSteps;
H1=GetHighTD(Step);
H2=GetNextHighTD(H1);
L1=GetLowTD(Step);
L2=GetNextLowTD(L1);
TrendLineBreakUp=High[H2]-(High[H2]-High[H1])/(H2-H1)*H2;//added line
TrendLineBreakDown=Low[L2]+(Low[L1]-Low[L2])/(L2-L1)*L2;//added line
if (H1<0)
Comm=Comm+"UTD no TD up-point \n";
else
if (H2<0)
Comm=Comm+"UTD no TD point-upper then last one ("+DoubleToStr(High[H1],j)+")\n";
else
Comm=Comm+"UTD "+DoubleToStr(High[H2],j)+" "+DoubleToStr(High[H1],j)+"\n";
if (L1<0)
Comm=Comm+"LTD no TD down-point \n";
else
if (L2<0)
Comm=Comm+"LTD no TD point-lower then last one ("+DoubleToStr(Low[L1],j)+")\n";
else
Comm=Comm+"LTD "+DoubleToStr(Low[L2],j)+" "+DoubleToStr(Low[L1],j)+"\n";
//-----------------------------------------------------------------------------------
if (Step==1)
Style=STYLE_SOLID;
else
Style=STYLE_DOT;
if (H1>0 && H2>0)
{
if (TrendLine==1)
{
ObjectCreate("HL_"+Step,OBJ_TREND,0,0,0,0,0);
TrendLineHighTD(H1,H2,Step,Col[Step*2-2]);
}
else
ObjectDelete("HL_"+Step);
if (HorizontLine==1 && Step==1)
{
ObjectCreate("HHL_"+Step,OBJ_HLINE,0,0,0,0,0);
ObjectSet("HHL_"+Step,OBJPROP_BACK,True);//Line added
}
else
ObjectDelete("HHL_"+Step);
if (ProjectionLines==1)
{
ObjectCreate("HC1_"+Step,OBJ_TREND,0,0,0,0,0);
ObjectCreate("HC2_"+Step,OBJ_TREND,0,0,0,0,0);
ObjectCreate("HC3_"+Step,OBJ_TREND,0,0,0,0,0);
//Comm=Comm+TakeProfitHighTD(H1,H2,Step,Col[Step*2-2]);
}
else
{
ObjectDelete("HC1_"+Step);
ObjectDelete("HC2_"+Step);
ObjectDelete("HC3_"+Step);
}
}
//-----------------------------------------------------------------------------------
if (L1>0 && L2>0)
{
if (TrendLine==1)
{
ObjectCreate("LL_"+Step,OBJ_TREND,0,0,0,0,0);
TrendLineLowTD(L1,L2,Step,Col[Step*2-1]);
}
else
ObjectDelete("LL_"+Step);
if (HorizontLine==1 && Step==1)
{
ObjectCreate("HLL_"+Step,OBJ_HLINE,0,0,0,0,0);
ObjectSet("HLL_"+Step,OBJPROP_BACK,True);//Line added
}
else
ObjectDelete("HLL_"+Step);
if (ProjectionLines==1)
{
ObjectCreate("LC1_"+Step,OBJ_TREND,0,0,0,0,0);
ObjectCreate("LC2_"+Step,OBJ_TREND,0,0,0,0,0);
ObjectCreate("LC3_"+Step,OBJ_TREND,0,0,0,0,0);
//Comm=Comm+TakeProfitLowTD(L1,L2,Step,Col[Step*2-1]);
}
else
{
ObjectDelete("LC1_"+Step);
ObjectDelete("LC2_"+Step);
ObjectDelete("LC3_"+Step);
}
}
}
//** Fonction en test **
bool IsNewBar()
{
static datetime lastbar = 0;
datetime curbar = Time[0];
if(lastbar!= curbar)
{
lastbar=curbar;
return (true);
}
else
{
return(false) ;
}
}
//+------------------------------------------------------------------+
//| fonction de demarrage de l'expert |
//+------------------------------------------------------------------+
int start()
{
//==============Indicateur Mouteki==============================
string Comm="";
SetTDPoint(Bars-1);
if (TD==1)
{
SetIndexArrow(0,217);
SetIndexArrow(1,218);
}
else
{
SetIndexArrow(0,160);
SetIndexArrow(1,160);
}
if (ShowingSteps>10)
{
Comment("ShowingSteps readings 0 - 10");
return(0);
}
for (int i=1;i<=ShowingSteps;i++)
{
Comm=Comm+TDMain(i);
Comm=Comm+"------------------------------------\nShowingSteps="+ShowingSteps+"\nBackSteps="+BackSteps;
if (FractalAsTD==true)
Comm=Comm+"\nFractals";
else
Comm=Comm+"\nTD point";
if (Comments==1)
Comment(Comm);
else
Comment("");
}
//==============EA Mouteki==============================
int cnt, H1, H2, L1, L2, ii, iii, pos, total, ticket;
double kH, kL, k, pp, tp, sl;
//--- Calcul du lancement du Trailing Stop ---//
// il faudrait amméliorer le trailing stop pour qu'il suive le mouvement de PositiveSL
//--Calcul
total=OrdersTotal();
for(cnt=0;cnt<total;cnt++)
{
if (OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES)==True)
{
if(OrderType()<=OP_SELL && OrderSymbol()==Symbol())
{
if(OrderType()==OP_BUY && Bid-OrderOpenPrice()>=ProfitToMoveSL*Point &&
OrderOpenPrice()-OrderStopLoss()>=0)
{
OrderModify(OrderTicket(),OrderOpenPrice(),OrderOpenPrice()+PositiveSL*Point,OrderTakeProfit(),0);
continue;
}
if(OrderType()==OP_SELL && OrderOpenPrice()-Ask>=ProfitToMoveSL*Point &&
OrderOpenPrice()-OrderStopLoss()<=0)
{
OrderModify(OrderTicket(),OrderOpenPrice(),OrderOpenPrice()-PositiveSL*Point,OrderTakeProfit(),0);
continue;
}
}
}
else
Print("OrderSelect returned the error of ",GetLastError());
}
//--- Les Trend Line ---//
//-- Où sont-elles?
SetTDPoint(Bars-1);
H1=GetHighTD(1);
H2=GetNextHighTD(H1);
L1=GetLowTD(1);
L2=GetNextLowTD(L1);
kH=(High[H2]-High[H1])/(H2-H1);
kL=(Low[L1]-Low[L2])/(L2-L1);
TrendLineBreakUp=High[H2]-kH*H2;
TrendLineBreakUpPrev=High[H2]-kH*(H2-1);
TrendLineBreakUpPrev1=High[H2]-kH*(H2-2);
TrendLineBreakDown=Low[L2]+kL*L2;
TrendLineBreakDownPrev=Low[L2]+kL*(L2-1);
TrendLineBreakDownPrev1=Low[L2]+kL*(L2-2);
//=====================SIGNAL1=======================
//-- Cassure des 2 Trend Line? Wait!
if(Open[0]>TrendLineBreakUp && Open[0]<TrendLineBreakDown)
// && H2<50 && L2<50)
{
BothTLBroken=True;
ArrayInitialize(highs, 0.0);
ArrayInitialize(lows, 0.0);
return(0);
}
//-- Cassure de la Trend Line du Haut ?
//if(Open[0]<TrendLineBreakUp)
if(Close[0]>TrendLineBreakUp && Open[0]<TrendLineBreakUp && TrendLineBreakUpFlag==False)
{
BothTLBroken=False;
TrendLineBreakUpFlag=True;
//Print("Upper TrendLine Break ",Symbol()," ",Period()," ",Bid);
if(AlertsOn)
Alert("UTL Break>",TrendLineBreakUp," on ",Symbol()," ",Period()," @ ",Ask);
}
//-- Long à la cassure de la trend line ??
if (pos==0||MultiPositions && Close[0]>TrendLineBreakUp)
{
Print("Ready to open a long trade");
//-- Ordre d'achat
ticket=OrderSend(Symbol(),OP_BUY,LotsOptimized(),Ask,3,sl,tp,"Mouteki",00011,0,Green);
if(ticket>0)
{
if(OrderSelect(ticket,SELECT_BY_TICKET,MODE_TRADES))
{
Print("Long order opened : ",OrderOpenPrice());
//--Ordre passé réinitialisation des variables
ArrayInitialize(highs, 0.0);
ArrayInitialize(lows, 0.0);
TrendLineBreakUp = False;
isBuying = False;
}
else Print("Error opening Long order : ",GetLastError());
}
}
//-- Cassure de la Trend Line du Bas ?
//if(Open[0]<TrendLineBreakDown)
if(Close[0]<TrendLineBreakDown && TrendLineBreakDownFlag==False)
{
BothTLBroken=False;
TrendLineBreakDownFlag=True;
//Print("Lower Trendline Break ",Symbol()," ",Period()," ",Bid);
if(AlertsOn)
Alert("LTL Break<",TrendLineBreakDown," on ",Symbol()," ",Period()," @ ",Bid);
}
//=====================SIGNAL2=======================
//==============Prise de Décision==============================
//--- Opération Horaire ---//
// Les 10 premières seconde de chaque bougie de 4H
//if (MathMod(Hour(),4)==0 && Minute()==0 && Seconds()<10)
if (IsNewBar())
{
//if (TrendLineBreakUpFlag == True && Open[0]>TrendLineBreakUp)
if (TrendLineBreakUpFlag == True && Open[0]>TrendLineBreakUp && Close[-1]>TrendLineBreakUp)
{
isBuying = True;
}
//if (TrendLineBreakDownFlag == True && Open[0]<TrendLineBreakDown)
if (TrendLineBreakDownFlag == True && Close[0]<TrendLineBreakDown)
{
isSelling = True;
}
}
//=====================Prise de position=======================
//-- Conditions d'achat
if(isBuying && !isSelling && !isClosing)
{
//-- Calcul de la Projection de Prix
/*
int i,ii,j=0;
double kH,HC1,HC2,HC3,k,St;
kH=(High[H2]-High[H1])/(H2-H1);
while (NormalizeDouble(Point,j)==0)j++;
k=0;
for(i=H1;i>0;i--)
if(Close[i]>High[H2]-kH*(H2-i))
{k=High[H2]-kH*(H2-i);
break;}
if (k>0)
{
ii=Lowest(NULL,0,MODE_LOW,H2-i,i);
HC1=High[H2]-kH*(H2-ii)-Low[ii];
HC2=High[H2]-kH*(H2-ii)-Close[ii];
ii=Lowest(NULL,0,MODE_CLOSE,H2-i,i);
HC3=High[H2]-kH*(H2-ii)-Close[ii];
}
else
{
k=High[H2]-kH*H2;
ii=Lowest(NULL,0,MODE_LOW,H2,0);
HC1=High[H2]-kH*(H2-ii)-Low[ii];
HC2=High[H2]-kH*(H2-ii)-Close[ii];
ii=Lowest(NULL,0,MODE_CLOSE,H2,0);
HC3=High[H2]-kH*(H2-ii)-Close[ii];
}
*/
// Il y a une couille à vérifier parce que jamais atteinte
ii=Lowest(NULL,0,MODE_LOW,H2-1,1);
iii=Lowest(NULL,0,MODE_LOW,H2-H1,H1);
pp=MathMax(High[H2]-kH*(H2-ii)-Low[ii], High[H2]-kH*(H2-iii)-Low[iii]);
//-- Calcul du StopLoss et du Take Profit
tp=pp-spread*Point+Open[0]+TP_Offset*Point;
if (pp>90*Point)
sl=Open[0]-spread*Point-MathRound(10000*pp*0.33)/10000-SL_Offset*Point;
else
sl=Open[0]-spread*Point-MathRound(10000*pp*0.5)/10000-SL_Offset*Point;
/*Ca pue les pieds la, il faudra dépatouiller tout ça */
// Short exists? Close it. Long exists? Change it.
total=OrdersTotal();
pos=0;
for(cnt=0;cnt<total;cnt++)
{
if (OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES)==True)
{
/*
// Close the shorts
if(OrderType()==OP_SELL && OrderSymbol()==Symbol())
{
OrderClose(OrderTicket(),OrderLots(),Ask,3,Violet);
continue;
}
*/
// Modify the longs
if(OrderType()==OP_BUY && OrderSymbol()==Symbol())
{
pos++;
OrderModify(OrderTicket(),OrderOpenPrice(),sl,tp,0);
continue;
}
}
else
Print("OrderSelect returned the error of ",GetLastError());
}
Print("pos=", pos, " MultiPositions=", MultiPositions);
// Long à la cassure de la Trend Line Haut
if (pos==0||MultiPositions)
{
Print("Ready to open a long trade");
//-- Ordre d'achat
ticket=OrderSend(Symbol(),OP_BUY,LotsOptimized(),Ask,3,sl,tp,"Mouteki",00011,0,Green);
if(ticket>0)
{
if(OrderSelect(ticket,SELECT_BY_TICKET,MODE_TRADES))
Print("Long order opened : ",OrderOpenPrice());
/*
Print("H1=", H1, " High[H1]=", High[H1]);
Print("H2=", H2, " High[H2]=", High[H2]);
Print("L1=", L1, " Low[L1]=", Low[L1]);
Print("L2=", L2, " Low[L2]=", Low[L2]);
Print("TrendLineBreakUp=", TrendLineBreakUp);
Print("TrendLineBreakDown=", TrendLineBreakDown);
Print("Open[0]=", Open[0], " Open[1]=", Open[1]);
*/
// Fin de la prise de position, réinitialisation des variables pour un autre tour
ArrayInitialize(highs, 0.0);
ArrayInitialize(lows, 0.0);
TrendLineBreakUp = False;
isBuying = False;
}
else Print("Error opening Long order : ",GetLastError());
}
// }
}
//-- Conditions de vente
if(isSelling && !isBuying && !isClosing)
{
//-- Calcul de la Projection de Prix
//Revoir à partir de calcul de prix du haut
// Il y a une couille target jamais atteind
ii=Highest(NULL,0,MODE_HIGH,L2-1,1);
iii=Highest(NULL,0,MODE_HIGH,L2-L1,L1);
pp=MathMax(High[ii]-(Low[L2]+kL*(L2-ii)), High[iii]-(Low[L2]+kL*(L2-iii)));
//-- Calcul du StopLoss et du Take Profit
tp=Open[0]-pp+spread*Point-TP_Offset*Point;
if (pp>90*Point)
sl=Open[0]+spread*Point+MathRound(10000*pp*0.33)/10000+SL_Offset*Point;
else
sl=Open[0]+spread*Point+MathRound(10000*pp*0.5)/10000+SL_Offset*Point;
/* ca re-pue des pieds */
// Long exists? Close it. Short exists? Change it.
total=OrdersTotal();
pos=0;
for(cnt=0;cnt<total;cnt++)
{
if (OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES)==True)
{
/*
// Close the longs
if(OrderType()==OP_BUY && OrderSymbol()==Symbol())
{
OrderClose(OrderTicket(),OrderLots(),Bid,3,Violet);
continue;
}
*/
// Modify the shorts
if(OrderType()==OP_SELL && OrderSymbol()==Symbol())
{
pos++;
OrderModify(OrderTicket(),OrderOpenPrice(),sl,tp,0);
continue;
}
}
else
Print("OrderSelect returned the error of ",GetLastError());
}
// Short à la cassure de la Trend Line Bas
if (pos==0||MultiPositions)
{
Print("Ready to open a short trade");
//-- Ordre de vente
ticket=OrderSend(Symbol(),OP_SELL,LotsOptimized(),Bid,3,sl,tp,"Mouteki",00021,0,Red);
if(ticket>0)
{
if(OrderSelect(ticket,SELECT_BY_TICKET,MODE_TRADES))
Print("Short order opened : ",OrderOpenPrice());
/*
Print("H1=", H1, " High[H1]=", High[H1]);
Print("H2=", H2, " High[H2]=", High[H2]);
Print("L1=", L1, " Low[L1]=", Low[L1]);
Print("L2=", L2, " Low[L2]=", Low[L2]);
Print("TrendLineBreakUp=", TrendLineBreakUp);
Print("TrendLineBreakDown=", TrendLineBreakDown);
Print("Open[0]=", Open[0], " Open[1]=", Open[1]);
*/
// Fin de la prise de position, réinitialisation des variables pour un autre tour
ArrayInitialize(highs, 0.0);
ArrayInitialize(lows, 0.0);
TrendLineBreakDown = False;
isSelling = False;
}
else Print("Error opening Long order : ",GetLastError());
}
}
//-- Conditions de cloture
// if(isClosing && !isSelling && !isBuying)
// {
// }
// ArrayInitialize(highs, 0.0);
// ArrayInitialize(lows, 0.0);
// }
// }
//----
return(0);
}
//+------------------------------------------------------------------+
Sample
Analysis
Market Information Used:
Series array that contains the highest prices of each bar
Series array that contains the lowest prices of each bar
Series array that contains open time of each bar
Series array that contains close prices for each bar
Series array that contains open prices of each bar
Indicator Curves created:
Implements a curve of type DRAW_ARROW
Indicators Used:
Custom Indicators Used:
Order Management characteristics:
Checks for the total of open orders
It can change open orders parameters, due to possible stepping strategy
It automatically opens orders when conditions are reached
It Closes Orders by itself
Other Features:
It issuies visual alerts to the screen