408 lines
14 KiB
Plaintext
408 lines
14 KiB
Plaintext
//+------------------------------------------------------------------+
|
|
//| PaPP_Trading.mq5 |
|
|
//| PaPP Trading |
|
|
//+------------------------------------------------------------------+
|
|
#property copyright "PaPP Trading"
|
|
#property version "2.00"
|
|
#property description "PaPP Trading - Multi timeframe MA + volatilita + accelerazione"
|
|
#property indicator_chart_window
|
|
#property indicator_buffers 10
|
|
#property indicator_plots 10
|
|
|
|
input bool ShowLines = false;
|
|
input int FontSize = 9;
|
|
input int XPos = 10;
|
|
input int YPos = 30;
|
|
input int TP_Points = 100; // Take Profit (punti)
|
|
input int SL_Points = 10000; // Stop Loss (punti)
|
|
input bool ShowTPSL = true; // Draw TP/SL lines on chart
|
|
|
|
//--- indicator buffers (SetIndexBuffer bound)
|
|
double B1Y[], B6M[], B4M[], B1Mo[], B2W[], B1W[], B3D[], B1D[], BSc[], BAc[];
|
|
|
|
//--- handles
|
|
int hMA[8];
|
|
int bars[8];
|
|
string pN[8] = {"1Y","6M","4M","1M","2W","1W","3G","1G"};
|
|
string _pfx = "PP_";
|
|
|
|
//--- rolling volatility window
|
|
double hMin[8], hMax[8];
|
|
int volResetBar[8]; // bar index (non-series) of last reset
|
|
int WINDOW = 200; // rolling window bars
|
|
|
|
//--- last bar tracking for dashboard update
|
|
datetime lastBarTime = 0;
|
|
|
|
//+------------------------------------------------------------------+
|
|
int TimeToBars(int days)
|
|
{
|
|
datetime now = TimeCurrent();
|
|
if(now==0)
|
|
{
|
|
long s = (long)days*86400L;
|
|
long p = PeriodSeconds((ENUM_TIMEFRAMES)_Period);
|
|
return (int)MathMax(1,s/p);
|
|
}
|
|
datetime then = now - days*86400;
|
|
int cnt = Bars(_Symbol,_Period,then,now);
|
|
return MathMax(1,cnt);
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
int OnInit()
|
|
{
|
|
IndicatorSetString(INDICATOR_SHORTNAME,"PaPP Trading v2");
|
|
IndicatorSetInteger(INDICATOR_DIGITS,_Digits);
|
|
|
|
int days[8] = {365,182,121,30,14,7,3,1};
|
|
for(int i=0;i<8;i++)
|
|
{
|
|
bars[i] = (i<7) ? TimeToBars(days[i]) : 1;
|
|
hMA[i]=iMA(_Symbol,_Period,bars[i],0,MODE_SMA,PRICE_CLOSE);
|
|
if(hMA[i]==INVALID_HANDLE) return INIT_FAILED;
|
|
}
|
|
|
|
SetIndexBuffer(0,B1Y,INDICATOR_DATA); ArraySetAsSeries(B1Y,true);
|
|
SetIndexBuffer(1,B6M,INDICATOR_DATA); ArraySetAsSeries(B6M,true);
|
|
SetIndexBuffer(2,B4M,INDICATOR_DATA); ArraySetAsSeries(B4M,true);
|
|
SetIndexBuffer(3,B1Mo,INDICATOR_DATA); ArraySetAsSeries(B1Mo,true);
|
|
SetIndexBuffer(4,B2W,INDICATOR_DATA); ArraySetAsSeries(B2W,true);
|
|
SetIndexBuffer(5,B1W,INDICATOR_DATA); ArraySetAsSeries(B1W,true);
|
|
SetIndexBuffer(6,B3D,INDICATOR_DATA); ArraySetAsSeries(B3D,true);
|
|
SetIndexBuffer(7,B1D,INDICATOR_DATA); ArraySetAsSeries(B1D,true);
|
|
SetIndexBuffer(8,BSc,INDICATOR_DATA); ArraySetAsSeries(BSc,true);
|
|
SetIndexBuffer(9,BAc,INDICATOR_DATA); ArraySetAsSeries(BAc,true);
|
|
|
|
color cl[10] = {clrRed,clrOrange,clrGold,clrLimeGreen,
|
|
clrDodgerBlue,clrViolet,clrBrown,clrGray,clrCyan,clrMagenta};
|
|
for(int i=0;i<8;i++)
|
|
{
|
|
PlotIndexSetInteger(i,PLOT_DRAW_TYPE,ShowLines?DRAW_LINE:DRAW_NONE);
|
|
PlotIndexSetInteger(i,PLOT_LINE_COLOR,cl[i]);
|
|
PlotIndexSetString(i,PLOT_LABEL,pN[i]+" MA");
|
|
PlotIndexSetInteger(i,PLOT_LINE_WIDTH,2);
|
|
}
|
|
PlotIndexSetInteger(8,PLOT_DRAW_TYPE,DRAW_NONE);
|
|
PlotIndexSetInteger(9,PLOT_DRAW_TYPE,DRAW_NONE);
|
|
|
|
for(int i=0;i<8;i++) { hMin[i]=1e10; hMax[i]=-1e10; volResetBar[i]=0; }
|
|
|
|
return INIT_SUCCEEDED;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
void OnDeinit(const int reason)
|
|
{
|
|
for(int i=0;i<8;i++)
|
|
if(hMA[i]!=INVALID_HANDLE) IndicatorRelease(hMA[i]);
|
|
ObjectsDeleteAll(0,_pfx);
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Buffer helpers (separate MA index from bar index) |
|
|
//+------------------------------------------------------------------+
|
|
void SetMA(int b, int bar, double v)
|
|
{
|
|
if(b==0) B1Y[bar]=v; else if(b==1) B6M[bar]=v; else if(b==2) B4M[bar]=v;
|
|
else if(b==3) B1Mo[bar]=v; else if(b==4) B2W[bar]=v; else if(b==5) B1W[bar]=v;
|
|
else if(b==6) B3D[bar]=v; else if(b==7) B1D[bar]=v;
|
|
}
|
|
double GetMA(int bar, int m)
|
|
{
|
|
if(m==0) return B1Y[bar]; if(m==1) return B6M[bar]; if(m==2) return B4M[bar];
|
|
if(m==3) return B1Mo[bar]; if(m==4) return B2W[bar]; if(m==5) return B1W[bar];
|
|
if(m==6) return B3D[bar]; return B1D[bar];
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
int OnCalculate(const int rates_total,
|
|
const int prev_calculated,
|
|
const datetime &time[],
|
|
const double &open[],
|
|
const double &high[],
|
|
const double &low[],
|
|
const double &close[],
|
|
const long &tick_volume[],
|
|
const long &volume[],
|
|
const int &spread[])
|
|
{
|
|
if(rates_total<2) return 0;
|
|
|
|
ArraySetAsSeries(close,true);
|
|
ArraySetAsSeries(time,true);
|
|
|
|
//--- limit = number of new bars to process
|
|
int limit = rates_total - prev_calculated;
|
|
if(limit>1) limit = rates_total-1;
|
|
|
|
//--- Copy only the needed range (performance)
|
|
// needed = limit+1 bars from position startPos
|
|
int needed = limit + 1;
|
|
int startPos = rates_total - needed;
|
|
if(startPos<0) { startPos=0; needed=rates_total; }
|
|
|
|
//--- Temp arrays for MA data
|
|
double tmp[8][];
|
|
for(int m=0;m<8;m++)
|
|
{
|
|
ArrayResize(tmp[m],needed);
|
|
int copied = CopyBuffer(hMA[m],0,startPos,needed,tmp[m]);
|
|
if(copied<needed)
|
|
{
|
|
// Not enough data, zero-fill remaining
|
|
for(int i=(copied>0?copied:0);i<needed;i++) tmp[m][i]=0;
|
|
}
|
|
ArraySetAsSeries(tmp[m],true);
|
|
}
|
|
|
|
//--- Assign temp -> indicator buffers (series indexed: idx=0=newest)
|
|
for(int idx=limit; idx>=0; idx--)
|
|
{
|
|
double mv[8];
|
|
for(int m=0;m<8;m++)
|
|
{
|
|
if(idx<needed) mv[m]=tmp[m][idx];
|
|
else mv[m]=GetMA(idx,m); // fallback (shouldn't happen)
|
|
SetMA(m, idx, mv[m]);
|
|
}
|
|
|
|
double p = close[idx];
|
|
|
|
//--- Velocities: need prev bar
|
|
double vel[8];
|
|
for(int m=0;m<8;m++)
|
|
{
|
|
double prv;
|
|
if(idx+1<rates_total)
|
|
{
|
|
if(idx+1<needed) prv=tmp[m][idx+1];
|
|
else prv=GetMA(idx+1,m); // from previously calculated data
|
|
}
|
|
else prv=mv[m];
|
|
vel[m]=mv[m]-prv;
|
|
}
|
|
|
|
//--- Score
|
|
int sc=0;
|
|
for(int m=0;m<8;m++) sc += (p>mv[m]) ? 1 : -1;
|
|
BSc[idx]=sc;
|
|
|
|
//--- Acceleration
|
|
double aSum=0;
|
|
for(int m=0;m<7;m++) aSum+=(vel[m]-vel[m+1]);
|
|
BAc[idx]=aSum/7.0;
|
|
|
|
//--- Rolling volatility window: reset & rebuild every WINDOW bars
|
|
// volResetBar tracks the non-series bar index of last reset
|
|
// Non-series index = rates_total - 1 - idx (since idx is series)
|
|
int nsIdx = rates_total - 1 - idx; // non-series index (0=oldest)
|
|
if(nsIdx == volResetBar[0] + WINDOW)
|
|
{
|
|
// Time to reset: scan back WINDOW bars to recompute min/max
|
|
for(int m=0;m<8;m++) { hMin[m]=1e10; hMax[m]=-1e10; }
|
|
int scanStart = MathMax(0, nsIdx - WINDOW);
|
|
int scanEnd = MathMin(rates_total-1, nsIdx);
|
|
for(int s=scanStart; s<=scanEnd; s++)
|
|
{
|
|
int si = rates_total - 1 - s; // series index
|
|
double pp = close[si];
|
|
for(int m=0;m<8;m++)
|
|
{
|
|
double vm = GetMA(si,m);
|
|
if(vm>0)
|
|
{
|
|
double d = MathAbs(pp - vm);
|
|
if(d<hMin[m]) hMin[m]=d;
|
|
if(d>hMax[m]) hMax[m]=d;
|
|
}
|
|
}
|
|
}
|
|
for(int m=0;m<8;m++) volResetBar[m]=nsIdx;
|
|
}
|
|
else
|
|
{
|
|
// Normal update: extend min/max if this bar pushes them
|
|
for(int m=0;m<8;m++)
|
|
{
|
|
if(mv[m]>0)
|
|
{
|
|
double d = MathAbs(p-mv[m]);
|
|
if(d<hMin[m]) hMin[m]=d;
|
|
if(d>hMax[m]) hMax[m]=d;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//--- Dashboard: only on new bar or first run
|
|
bool newBar = (time[0]!=lastBarTime);
|
|
if(newBar || prev_calculated==0)
|
|
{
|
|
lastBarTime = time[0];
|
|
DrawDashboard();
|
|
}
|
|
|
|
return rates_total;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
void DrawDashboard()
|
|
{
|
|
double mv[8], vel[8];
|
|
double bid = SymbolInfoDouble(_Symbol,SYMBOL_BID);
|
|
|
|
for(int m=0;m<8;m++)
|
|
{
|
|
mv[m]=GetMA(0,m);
|
|
double prv = (GetMA(1,m)>0) ? GetMA(1,m) : mv[m];
|
|
vel[m]=mv[m]-prv;
|
|
}
|
|
|
|
string tf = EnumToString((ENUM_TIMEFRAMES)_Period);
|
|
int x=XPos, y=YPos, lh=FontSize+4;
|
|
|
|
//--- Title
|
|
Lbl("T",_Symbol+" PaPP ["+tf+"] v2",x,y,FontSize+2,clrGold,true);
|
|
y+=lh+4;
|
|
|
|
double c0=GetMA(0,7); // B1D[0] = SMA(1) = latest close
|
|
double c1=GetMA(1,7);
|
|
Lbl("P","Oggi: "+DTS(c0,_Digits)+" | Ieri: "+DTS(c1,_Digits),x,y,FontSize,clrWhite,false);
|
|
y+=lh+2;
|
|
|
|
Lbl("S1","------------------------------",x,y,FontSize-1,clrGold,false);
|
|
y+=lh;
|
|
|
|
string hdr = StringFormat("%-6s %-12s %-4s %-8s %-5s %-7s","Periodo","Media","Pos","Dist","Vol%","Veloc");
|
|
Lbl("H",hdr,x,y,FontSize,clrGold,false);
|
|
y+=lh;
|
|
|
|
for(int m=0;m<8;m++)
|
|
{
|
|
if(mv[m]<=0) continue;
|
|
double dist = bid-mv[m];
|
|
double absD = MathAbs(dist);
|
|
|
|
//--- Volatility % (rolling window)
|
|
double vn=50.0;
|
|
if(hMax[m]>hMin[m] && hMax[m]>0)
|
|
{ vn=((absD-hMin[m])/(hMax[m]-hMin[m]))*100.0; vn=MathMax(0,MathMin(100,vn)); }
|
|
|
|
string row = StringFormat("%-6s %-12.*f %-4s %-+8.*f %-5.0f%% %-+7.*f",
|
|
pN[m],_Digits,mv[m],
|
|
(dist>0)?"SU":"GIU",
|
|
_Digits,dist,vn,_Digits,vel[m]);
|
|
Lbl("R"+(string)m,row,x,y,FontSize,(dist>0)?clrLimeGreen:clrRed,false);
|
|
y+=lh;
|
|
}
|
|
|
|
Lbl("S2","------------------------------",x,y,FontSize-1,clrGold,false);
|
|
y+=lh;
|
|
|
|
//--- Score
|
|
int sc = (int)BSc[0];
|
|
string sS = StringFormat("SCORE: %+d/8",sc);
|
|
string sD = " [LATERALE]";
|
|
if(sc>=5) sD=" [IPERCOMPRATO]";
|
|
else if(sc<=-5) sD=" [IPERVENDUTO]";
|
|
else if(sc>=2) sD=" [RIALZO]";
|
|
else if(sc<=-2) sD=" [RIBASSO]";
|
|
Lbl("Sc",sS+sD,x,y,FontSize+1,(sc>=2)?clrLimeGreen:(sc<=-2)?clrRed:clrGray,true);
|
|
y+=lh+2;
|
|
|
|
//--- Acceleration (threshold based on _Point)
|
|
double acc = BAc[0];
|
|
double accThresh = _Point * 10.0;
|
|
string aS = StringFormat("ACCEL: %+.*f",_Digits+1,acc);
|
|
string aD = " [STABILE/FRENATA]";
|
|
if(acc>accThresh) aD=" [ACCELERAZIONE +]";
|
|
else if(acc<-accThresh) aD=" [ACCELERAZIONE -]";
|
|
Lbl("Ac",aS+aD,x,y,FontSize+1,(acc>accThresh)?clrLimeGreen:(acc<-accThresh)?clrRed:clrGray,true);
|
|
y+=lh;
|
|
|
|
//--- Average volatility
|
|
double vAvg=0; int vCnt=0;
|
|
for(int m=0;m<8;m++)
|
|
{
|
|
if(mv[m]>0 && hMax[m]>hMin[m] && hMax[m]>0)
|
|
{
|
|
double ad=MathAbs(bid-mv[m]);
|
|
double vn=((ad-hMin[m])/(hMax[m]-hMin[m]))*100.0;
|
|
vAvg+=MathMax(0,MathMin(100,vn)); vCnt++;
|
|
}
|
|
}
|
|
if(vCnt>0) vAvg/=vCnt;
|
|
string vS = StringFormat("VOL: %.0f%%",vAvg);
|
|
string vD = " [NORMALE]";
|
|
if(vAvg>70) vD=" [ALTA - breakout in corso]";
|
|
else if(vAvg<40) vD=" [BASSA - compressione]";
|
|
Lbl("Vo",vS+vD,x,y,FontSize+1,(vAvg>70)?clrRed:(vAvg>40)?clrYellow:clrLimeGreen,true);
|
|
y+=lh+2;
|
|
Lbl("TPSL","TP: +"+string(TP_Points)+" pt ("+DTS(bid+TP_Points*_Point,_Digits)+
|
|
") | SL: -"+string(SL_Points)+" pt ("+DTS(bid-SL_Points*_Point,_Digits)+")",
|
|
x,y,FontSize,clrGray,false);
|
|
y+=lh+6;
|
|
|
|
//--- TP/SL lines on chart
|
|
if(ShowTPSL)
|
|
{
|
|
string tpName = _pfx+"TPLINE";
|
|
string slName = _pfx+"SLLINE";
|
|
double tpPrice = bid + TP_Points * _Point;
|
|
double slPrice = bid - SL_Points * _Point;
|
|
if(ObjectFind(0,tpName)<0) ObjectCreate(0,tpName,OBJ_HLINE,0,0,0);
|
|
if(ObjectFind(0,slName)<0) ObjectCreate(0,slName,OBJ_HLINE,0,0,0);
|
|
ObjectSetDouble(0,tpName,OBJPROP_PRICE,tpPrice);
|
|
ObjectSetDouble(0,slName,OBJPROP_PRICE,slPrice);
|
|
ObjectSetInteger(0,tpName,OBJPROP_COLOR,clrLimeGreen);
|
|
ObjectSetInteger(0,slName,OBJPROP_COLOR,clrRed);
|
|
ObjectSetInteger(0,tpName,OBJPROP_WIDTH,1);
|
|
ObjectSetInteger(0,slName,OBJPROP_WIDTH,1);
|
|
ObjectSetInteger(0,tpName,OBJPROP_STYLE,STYLE_DASHDOT);
|
|
ObjectSetInteger(0,slName,OBJPROP_STYLE,STYLE_DASHDOT);
|
|
ObjectSetString(0,tpName,OBJPROP_TEXT,"TP +"+string(TP_Points)+" ("+DTS(tpPrice,_Digits)+")");
|
|
ObjectSetString(0,slName,OBJPROP_TEXT,"SL -"+string(SL_Points)+" ("+DTS(slPrice,_Digits)+")");
|
|
ObjectSetInteger(0,tpName,OBJPROP_BACK,true);
|
|
ObjectSetInteger(0,slName,OBJPROP_BACK,true);
|
|
ObjectSetInteger(0,tpName,OBJPROP_SELECTABLE,false);
|
|
ObjectSetInteger(0,slName,OBJPROP_SELECTABLE,false);
|
|
}
|
|
else
|
|
{
|
|
if(ObjectFind(0,_pfx+"TPLINE")>=0) ObjectDelete(0,_pfx+"TPLINE");
|
|
if(ObjectFind(0,_pfx+"SLLINE")>=0) ObjectDelete(0,_pfx+"SLLINE");
|
|
}
|
|
|
|
Lbl("L0","LEGENDA:",x,y,FontSize,clrGold,true);
|
|
y+=lh;
|
|
Lbl("L1","SU/GIU = prezzo sopra/sotto media | Vol% = 0(min)-100(max) rolling "+string(WINDOW),x,y,FontSize-1,clrWhite,false);
|
|
y+=lh-2;
|
|
Lbl("L2","Score +8=tutto rialzo -8=tutto ribasso ~0=laterale",x,y,FontSize-1,clrWhite,false);
|
|
y+=lh-2;
|
|
Lbl("L3","Accel +=forza in aumento -=forza in calo ~0=stabile/frenata",x,y,FontSize-1,clrWhite,false);
|
|
y+=lh-2;
|
|
Lbl("L4","Vol>70%=esplosione Vol<40%=compressione (molla)",x,y,FontSize-1,clrWhite,false);
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
void Lbl(string n,string t,int x,int y,int fs,color c,bool b)
|
|
{
|
|
string o=_pfx+n;
|
|
if(ObjectFind(0,o)<0) ObjectCreate(0,o,OBJ_LABEL,0,0,0);
|
|
ObjectSetInteger(0,o,OBJPROP_XDISTANCE,x);
|
|
ObjectSetInteger(0,o,OBJPROP_YDISTANCE,y);
|
|
ObjectSetInteger(0,o,OBJPROP_CORNER,CORNER_LEFT_UPPER);
|
|
ObjectSetString(0,o,OBJPROP_TEXT,t);
|
|
ObjectSetString(0,o,OBJPROP_FONT,b?"Lucida Console Bold":"Lucida Console");
|
|
ObjectSetInteger(0,o,OBJPROP_FONTSIZE,fs);
|
|
ObjectSetInteger(0,o,OBJPROP_COLOR,c);
|
|
ObjectSetInteger(0,o,OBJPROP_BACK,false);
|
|
ObjectSetInteger(0,o,OBJPROP_SELECTABLE,false);
|
|
ObjectSetInteger(0,o,OBJPROP_HIDDEN,true);
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
string DTS(double v,int d) { return DoubleToString(v,d); }
|
|
//+------------------------------------------------------------------+
|