SSSR_v3_EA Journal

im the owner broooooooo

Reading the posts to know how can i help u make that better, i have up to v8

fIRST OF ALL WE NEED UPDATE THE CODE OF THE INDICATORS, AS THEY ARE STILL CODED FOR LAST MT4 VERTION, IF SOMEONE WANTS TO RECODE THEM, THEN WE CAN MAKE IT BETTER FIRST OF ALL FORGET OF HULL MOVINGAVERAGE, I FOUND OUT THE EA WORKS BETTER SETTING LONGER THERM TRENDS, EXAMPLE YEAR 2012 ' 2015 2015 ' 2016 USES OTHER MOVING AVERAGES... SO NOT SO GOOD V4.

I ATTACH THE INDICATORS NEEDED TO BE MODIFIED NITO LATEST MT4 VERTION,

AND HAPPY TO SEE THIS THREAD!!!

IM HAPPY U LOVE THIS 2 YEAR AGO PROJECT!!

This are the indicator code mq4 we need update to latest mt4 code... I compile and get 84 errors on each of them

will look the ea and share code only with a coder who wants work on the project!! And with the one who started this thread about my ea

lets do it!! We need a coder only haha

whenever uwant bro im here now forexfactory member

nOW IS GOOD TIME BRO!! WE NEED COING SKILLS!!

Great to see you here, Daniel! Have been following your startegy at magix's forum. Hopefully someone ist able to update the code. Unfortunately I have no coding skills.
Cheers, S.

main problem is code out of date, we need it running on latest mt4 vertions

We could make a mix with this other old one potential $500 - 12000 in 3 month

here you go.
All compile error free, but have not been tested, so please check

easy job for a good coder thanks RedlineFred will check them

Ups

this was missing

lols i dont know where the codes are, form the very first one only have v2 code

we need this one to

And ea code i shared bros,

i really forgot about this ea haha was from the very first projects, then i started trading manually and went away of this, dont like much loosing time on eas,, but if someone can make it run better i am happy to join

$1000 TO $500.000 IN A YEAR




$500 TO $6.700.000 IN A YEAR

SO, sorry for big letters, forgot that..

So, what was main issue?? setups work for 2 periods during a year, one setup will work good for 4 months example then will change for 6 more month and then will change again for 2 more months... so i thought ok, we can use HMA that is simple moving averages to ty fid out the periods where this works. this is how i could get the first pic from previous post, found the perdios i needed that worked on both periods of time for that backtes... for previous time, problem is future time current time etc... could not find any way to include this into the ea, so ea basically is good for backtests not so good for forward test...

IN SIMPLE WORDS WE NEED TREND INDICATOR AND WHEN INDICATOR IS ON BUY MODE THE EA USES SETUP 1 AND WHEN INDICATOR IS IN SELL MODE WE USE EA SETUP 2, THIS FOR LONG THERM IM TALKING WEEK OR MONTH CHART TREND INDI NOT INTRADAY.

if you find out indicator for long therm that can fit this can be taken from virtuality to reality

here the code

Code:
enum _e_YesNo
{
No = 0,
Yes = 1
};

input _e_YesNo DebugMode = Yes;
input _e_YesNo UseAutoLot = No;
input int SSSR_TF = 1;


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

input _e_YesNo UT_Open_V_Support = No;
input _e_YesNo UT_Open_P_Support = Yes;
input _e_YesNo UT_Open_U_Support = Yes;
input _e_YesNo UT_Open_W_Support = Yes;
input _e_YesNo UT_Open_T_Support = Yes;
input _e_YesNo UT_Open_V_Resistance = Yes;
input _e_YesNo UT_Open_P_Resistance = Yes;
input _e_YesNo UT_Open_U_Resistance = Yes;
input _e_YesNo UT_Open_W_Resistance = No;
input _e_YesNo UT_Open_T_Resistance = No;

input _e_YesNo UT_Close_V_Support = No;
input _e_YesNo UT_Close_P_Support = Yes;
input _e_YesNo UT_Close_U_Support = Yes;
input _e_YesNo UT_Close_W_Support = No;
input _e_YesNo UT_Close_T_Support = No;
input _e_YesNo UT_Close_V_Resistance = Yes;
input _e_YesNo UT_Close_P_Resistance = No;
input _e_YesNo UT_Close_U_Resistance = No;
input _e_YesNo UT_Close_W_Resistance = Yes;
input _e_YesNo UT_Close_T_Resistance = No;

input _e_YesNo UT_Hedge_Mode = Yes;

input _e_YesNo UT_Hedge_V_Support = Yes;
input _e_YesNo UT_Hedge_P_Support = Yes;
input _e_YesNo UT_Hedge_U_Support = Yes;
input _e_YesNo UT_Hedge_W_Support = Yes;
input _e_YesNo UT_Hedge_T_Support = Yes;
input _e_YesNo UT_Hedge_V_Resistance = No;
input _e_YesNo UT_Hedge_P_Resistance = Yes;
input _e_YesNo UT_Hedge_U_Resistance = Yes;
input _e_YesNo UT_Hedge_W_Resistance = No;
input _e_YesNo UT_Hedge_T_Resistance = Yes;

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

input _e_YesNo DT_Open_V_Support = No;
input _e_YesNo DT_Open_P_Support = No;
input _e_YesNo DT_Open_U_Support = No;
input _e_YesNo DT_Open_W_Support = No;
input _e_YesNo DT_Open_T_Support = No;
input _e_YesNo DT_Open_V_Resistance = No;
input _e_YesNo DT_Open_P_Resistance = No;
input _e_YesNo DT_Open_U_Resistance = No;
input _e_YesNo DT_Open_W_Resistance = Yes;
input _e_YesNo DT_Open_T_Resistance = No;

input _e_YesNo DT_Close_V_Support = No;
input _e_YesNo DT_Close_P_Support = No;
input _e_YesNo DT_Close_U_Support = No;
input _e_YesNo DT_Close_W_Support = No;
input _e_YesNo DT_Close_T_Support = No;
input _e_YesNo DT_Close_V_Resistance = No;
input _e_YesNo DT_Close_P_Resistance = No;
input _e_YesNo DT_Close_U_Resistance = No;
input _e_YesNo DT_Close_W_Resistance = No;
input _e_YesNo DT_Close_T_Resistance = No;

input _e_YesNo DT_Hedge_Mode = Yes;

input _e_YesNo DT_Hedge_V_Support = Yes;
input _e_YesNo DT_Hedge_P_Support = Yes;
input _e_YesNo DT_Hedge_U_Support = Yes;
input _e_YesNo DT_Hedge_W_Support = No;
input _e_YesNo DT_Hedge_T_Support = No;
input _e_YesNo DT_Hedge_V_Resistance = Yes;
input _e_YesNo DT_Hedge_P_Resistance = No;
input _e_YesNo DT_Hedge_U_Resistance = No;
input _e_YesNo DT_Hedge_W_Resistance = Yes;
input _e_YesNo DT_Hedge_T_Resistance = No;

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

input double AutoLot = 5;
input double StaticLots = 0.01;
input double MaxLot = 100;
input int SleepMinutes = 60;
input int MaxTrades = 10;

input double TakeProfit = 0.0;
input double StopLoss = 0.0;
input double TrailingStopTrigger = 0.004;
input double TrailingStopPips = 0.001;

input int UT_DT_TimeFr_FILTER = 1440;

input int UT_DT_FastHMAperiod = 100;
input int UT_DT_FastHMAmethod = 3;
input int UT_DT_FastHMAprice = 0;

input int UT_DT_SlowHMAperiod = 400;
input int UT_DT_SlowHMAmethod = 2;
input int UT_DT_SlowHMAprice = 0;

input int Hedge_HMA_TimeFr = 0;

input int Hedge_FastHMAperiod = 23;
input int Hedge_FastHMAmethod = 3;
input int Hedge_FastHMAprice = 0;

input int Hedge_SlowHMAperiod = 50;
input int Hedge_SlowHMAmethod = 3;
input int Hedge_SlowHMAprice = 0;



input _e_YesNo TradingEntryTime = Yes;

int GMTOffsetOfBroker = 0;
input int TimezoneStartHour = 6,
TimezoneStartMinute = 0,
TimezoneEndHour = 18,
TimezoneEndMinute = 0;

input int MagicNumber = 12344;


#property copyright "Daniel Luchinger Moyano "
#property link "www.facebook.com/dluchinger"
#property version "2.00"
#property strict


int labelId = 0;
int y = 0;
//+------------------------------------------------------------------+
//| Expert initialization function |
//+------------------------------------------------------------------+
datetime lastOrderTime;

int OnInit()
{
//---
lastOrderTime = TimeCurrent();


//---
return(INIT_SUCCEEDED);
}
//+------------------------------------------------------------------+
//| Expert deinitialization function |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
//---

}
//+------------------------------------------------------------------+
//| Expert tick function |
//+------------------------------------------------------------------+
void OnTick()
{
resetObjects();
int orders = countOrders(-1);
bool tt = tradeTime();
label("Orders: "+IntegerToString(orders)+"/"+IntegerToString(MaxTrades));
if(!tt)label("OUT OF TRADE TIME");



double HTF_FastHMACurrent_0 = iCustom(Symbol(),UT_DT_TimeFr_FILTER,"HMA_Russian_Color",UT_DT_FastHMAperiod,UT_DT_FastHMAmethod,UT_DT_FastHMAprice,0,0);
double HTF_FastHMAPrevious_1 = iCustom(Symbol(),UT_DT_TimeFr_FILTER,"HMA_Russian_Color",UT_DT_FastHMAperiod,UT_DT_FastHMAmethod,UT_DT_FastHMAprice,1,0);
double HTF_SlowHMACurrent_0 = iCustom(Symbol(),UT_DT_TimeFr_FILTER,"HMA_Russian_Color",UT_DT_SlowHMAperiod,UT_DT_SlowHMAmethod,UT_DT_SlowHMAprice,0,1);
double HTF_SlowHMAPrevious_1 = iCustom(Symbol(),UT_DT_TimeFr_FILTER,"HMA_Russian_Color",UT_DT_SlowHMAperiod,UT_DT_SlowHMAmethod,UT_DT_SlowHMAprice,1,1);

double FastHMACurrent_0 = iCustom(Symbol(),60,"HMA_Russian_Color",Hedge_FastHMAperiod,Hedge_FastHMAmethod,Hedge_FastHMAprice,0,0);
double FastHMAPrevious_1 = iCustom(Symbol(),60,"HMA_Russian_Color",Hedge_FastHMAperiod,Hedge_FastHMAmethod,Hedge_FastHMAprice,1,0);
double SlowHMACurrent_0 = iCustom(Symbol(),60,"HMA_Russian_Color",Hedge_SlowHMAperiod,Hedge_SlowHMAmethod,Hedge_SlowHMAprice,0,1);
double SlowHMAPrevious_1 = iCustom(Symbol(),60,"HMA_Russian_Color",Hedge_SlowHMAperiod,Hedge_SlowHMAmethod,Hedge_SlowHMAprice,1,1);


double SSSR_VUR_UT = iCustom(Symbol(),SSSR_TF,"SSSR_VERIFIED_UT",4,0); //UT=UP-TREND DAILY CHART
double SSSR_VDR_UT = iCustom(Symbol(),SSSR_TF,"SSSR_VERIFIED_UT",5,0);
double SSSR_VUS_UT = iCustom(Symbol(),SSSR_TF,"SSSR_VERIFIED_UT",6,0);
double SSSR_VDS_UT = iCustom(Symbol(),SSSR_TF,"SSSR_VERIFIED_UT",7,0);
double SSSR_PUR_UT = iCustom(Symbol(),SSSR_TF,"SSSR_PROVEN_UT",4,0);
double SSSR_PDR_UT = iCustom(Symbol(),SSSR_TF,"SSSR_PROVEN_UT",5,0);
double SSSR_PUS_UT = iCustom(Symbol(),SSSR_TF,"SSSR_PROVEN_UT",6,0);
double SSSR_PDS_UT = iCustom(Symbol(),SSSR_TF,"SSSR_PROVEN_UT",7,0);
double SSSR_UUR_UT = iCustom(Symbol(),SSSR_TF,"SSSR_UNTESTED_UT",4,0);
double SSSR_UDR_UT = iCustom(Symbol(),SSSR_TF,"SSSR_UNTESTED_UT",5,0);
double SSSR_UUS_UT = iCustom(Symbol(),SSSR_TF,"SSSR_UNTESTED_UT",6,0);
double SSSR_UDS_UT = iCustom(Symbol(),SSSR_TF,"SSSR_UNTESTED_UT",7,0);
double SSSR_WUR_UT = iCustom(Symbol(),SSSR_TF,"SSSR_WEAK_UT",4,0);
double SSSR_WDR_UT = iCustom(Symbol(),SSSR_TF,"SSSR_WEAK_UT",5,0);
double SSSR_WUS_UT = iCustom(Symbol(),SSSR_TF,"SSSR_WEAK_UT",6,0);
double SSSR_WDS_UT = iCustom(Symbol(),SSSR_TF,"SSSR_WEAK_UT",7,0);
double SSSR_TUR_UT = iCustom(Symbol(),SSSR_TF,"SSSR_TURNCOAT_UT",4,0);
double SSSR_TDR_UT = iCustom(Symbol(),SSSR_TF,"SSSR_TURNCOAT_UT",5,0);
double SSSR_TUS_UT = iCustom(Symbol(),SSSR_TF,"SSSR_TURNCOAT_UT",6,0);
double SSSR_TDS_UT = iCustom(Symbol(),SSSR_TF,"SSSR_TURNCOAT_UT",7,0);

double SSSR_VUR_DT = iCustom(Symbol(),SSSR_TF,"SSSR_VERIFIED_DT",4,0); //DT=DOWN-TREND DAILY CHART
double SSSR_VDR_DT = iCustom(Symbol(),SSSR_TF,"SSSR_VERIFIED_DT",5,0);
double SSSR_VUS_DT = iCustom(Symbol(),SSSR_TF,"SSSR_VERIFIED_DT",6,0);
double SSSR_VDS_DT = iCustom(Symbol(),SSSR_TF,"SSSR_VERIFIED_DT",7,0);
double SSSR_PUR_DT = iCustom(Symbol(),SSSR_TF,"SSSR_PROVEN_DT",4,0);
double SSSR_PDR_DT = iCustom(Symbol(),SSSR_TF,"SSSR_PROVEN_DT",5,0);
double SSSR_PUS_DT = iCustom(Symbol(),SSSR_TF,"SSSR_PROVEN_DT",6,0);
double SSSR_PDS_DT = iCustom(Symbol(),SSSR_TF,"SSSR_PROVEN_DT",7,0);
double SSSR_UUR_DT = iCustom(Symbol(),SSSR_TF,"SSSR_UNTESTED_DT",4,0);
double SSSR_UDR_DT = iCustom(Symbol(),SSSR_TF,"SSSR_UNTESTED_DT",5,0);
double SSSR_UUS_DT = iCustom(Symbol(),SSSR_TF,"SSSR_UNTESTED_DT",6,0);
double SSSR_UDS_DT = iCustom(Symbol(),SSSR_TF,"SSSR_UNTESTED_DT",7,0);
double SSSR_WUR_DT = iCustom(Symbol(),SSSR_TF,"SSSR_WEAK_DT",4,0);
double SSSR_WDR_DT = iCustom(Symbol(),SSSR_TF,"SSSR_WEAK_DT",5,0);
double SSSR_WUS_DT = iCustom(Symbol(),SSSR_TF,"SSSR_WEAK_DT",6,0);
double SSSR_WDS_DT = iCustom(Symbol(),SSSR_TF,"SSSR_WEAK_DT",7,0);
double SSSR_TUR_DT = iCustom(Symbol(),SSSR_TF,"SSSR_TURNCOAT_DT",4,0);
double SSSR_TDR_DT = iCustom(Symbol(),SSSR_TF,"SSSR_TURNCOAT_DT",5,0);
double SSSR_TUS_DT = iCustom(Symbol(),SSSR_TF,"SSSR_TURNCOAT_DT",6,0);
double SSSR_TDS_DT = iCustom(Symbol(),SSSR_TF,"SSSR_TURNCOAT_DT",7,0);


// Trade Signals

double _sl = 0,_tp = 0;


{{
//Daily HMA filter
// la bajista probarla entre el 9/4/13 y el ultimo de mayo/13

//-------------------------------------------------------------------
//CODE FOR BUY FILTER HTF_HMA = HIGHT TIME FRAME HMA
//-------------------------------------------------------------------
if(((( HTF_FastHMACurrent_0 + HTF_FastHMAPrevious_1)/2 )-( HTF_SlowHMACurrent_0 + HTF_SlowHMAPrevious_1 )/2)> 0.001 ) // this is to compare segments between 0 (present bar) and 1(previous bar) // code by tomcat98
{

//-------------------------------------------------------------------
//-------------------------------------------------------------------
// BUY Signals Options
{
if(UT_Open_V_Support == Yes)
{
if(Close[0]<SSSR_VUS_UT && Close[0]>SSSR_VDS_UT)
{
if(StopLoss > 0) _sl = Ask - StopLoss;
if(TakeProfit > 0) _tp = Ask + TakeProfit;
if(orders<MaxTrades)
{
openOrder(getLots(),MagicNumber,OP_BUY, _sl,_tp);
}
}}

if(UT_Open_P_Support == Yes)
{
if(Close[0]<SSSR_PUS_UT && Close[0]>SSSR_PDS_UT)
{
if(StopLoss > 0) _sl = Ask - StopLoss;
if(TakeProfit > 0) _tp = Ask + TakeProfit;
if(orders<MaxTrades)
{
openOrder(getLots(),MagicNumber,OP_BUY, _sl,_tp);
}
}}

if(UT_Open_U_Support == Yes)
{
if(Close[0]<SSSR_UUS_UT && Close[0]>SSSR_UDS_UT)
{
if(StopLoss > 0) _sl = Ask - StopLoss;
if(TakeProfit > 0) _tp = Ask + TakeProfit;
if(orders<MaxTrades)
{
openOrder(getLots(),MagicNumber,OP_BUY, _sl,_tp);
}
}}

if(UT_Open_W_Support == Yes)
{
if(Close[0]<SSSR_WUS_UT && Close[0]>SSSR_WDS_UT)
{
if(StopLoss > 0) _sl = Ask - StopLoss;
if(TakeProfit > 0) _tp = Ask + TakeProfit;
if(orders<MaxTrades)
{
openOrder(getLots(),MagicNumber,OP_BUY, _sl,_tp);
}
}}

if(UT_Open_T_Support == Yes)
{
if(Close[0]<SSSR_TUS_UT && Close[0]>SSSR_TDS_UT)
{
if(StopLoss > 0) _sl = Ask - StopLoss;
if(TakeProfit > 0) _tp = Ask + TakeProfit;
if(orders<MaxTrades)
{
openOrder(getLots(),MagicNumber,OP_BUY, _sl,_tp);
}
}}
}
//-------------------------------------------------------------------
//-------------------------------------------------------------------
// Hedge Buy Signals Options

{
if(((( FastHMACurrent_0 + FastHMAPrevious_1)/2 )-( SlowHMACurrent_0 + SlowHMAPrevious_1 )/2)> 0.001 ) // this is to compare segments between 0 (present bar) and 1(previous bar) // code by tomcat98

{ {
if(UT_Hedge_Mode == Yes && UT_Hedge_V_Resistance == Yes) //HBHB= HMA FILTER BUY && HEDGE BUY
{
if(Close[0]>SSSR_VUR_UT)
{
if(StopLoss > 0) _sl = Ask - StopLoss;
if(TakeProfit > 0) _tp = Ask + TakeProfit;
if(orders<MaxTrades)
{
openOrder(getLots(),MagicNumber,OP_BUY, _sl,_tp);
}
}}

if(UT_Hedge_Mode == Yes && UT_Hedge_P_Resistance == Yes)
{
if(Close[0]>SSSR_PUR_UT)
{
if(StopLoss > 0) _sl = Ask - StopLoss;
if(TakeProfit > 0) _tp = Ask + TakeProfit;
if(orders<MaxTrades)
{
openOrder(getLots(),MagicNumber,OP_BUY, _sl,_tp);
}
}}

if(UT_Hedge_Mode == Yes && UT_Hedge_U_Resistance == Yes)
{
if(Close[0]>SSSR_UUR_UT)
{
if(StopLoss > 0) _sl = Ask - StopLoss;
if(TakeProfit > 0) _tp = Ask + TakeProfit;
if(orders<MaxTrades)
{
openOrder(getLots(),MagicNumber,OP_BUY, _sl,_tp);
}
}}

if(UT_Hedge_Mode == Yes && UT_Hedge_W_Resistance == Yes)
{
if(Close[0]>SSSR_WUR_UT)
{
if(StopLoss > 0) _sl = Ask - StopLoss;
if(TakeProfit > 0) _tp = Ask + TakeProfit;
if(orders<MaxTrades)
{
openOrder(getLots(),MagicNumber,OP_BUY, _sl,_tp);
}
}}

if(UT_Hedge_Mode == Yes && UT_Hedge_T_Resistance == Yes)
{
if(Close[0]>SSSR_TUR_UT)
{
if(StopLoss > 0) _sl = Ask - StopLoss;
if(TakeProfit > 0) _tp = Ask + TakeProfit;
if(orders<MaxTrades)
{
openOrder(getLots(),MagicNumber,OP_BUY, _sl,_tp);
}
}}}

}

//-------------------------------------------------------------------
//-------------------------------------------------------------------
// SELL signals options
{
if(UT_Open_V_Resistance == Yes)
{
if(Close[0]<SSSR_VUR_UT && Close[0]>SSSR_VDR_UT)
{
if(StopLoss > 0) _sl = Bid + StopLoss;
if(TakeProfit > 0) _tp = Bid - TakeProfit;
if(orders<MaxTrades)
{
openOrder(getLots(),MagicNumber,OP_SELL, _sl,_tp);
}}
}

if(UT_Open_P_Resistance == Yes)
{
if(Close[0]<SSSR_PUR_UT && Close[0]>SSSR_PDR_UT)
{
if(StopLoss > 0) _sl = Bid + StopLoss;
if(TakeProfit > 0) _tp = Bid - TakeProfit;
if(orders<MaxTrades)
{
openOrder(getLots(),MagicNumber,OP_SELL, _sl,_tp);
}}
}

if(UT_Open_U_Resistance == Yes)
{
if(Close[0]<SSSR_UUR_UT && Close[0]>SSSR_UDR_UT)
{
if(StopLoss > 0) _sl = Bid + StopLoss;
if(TakeProfit > 0) _tp = Bid - TakeProfit;
if(orders<MaxTrades)
{
openOrder(getLots(),MagicNumber,OP_SELL, _sl,_tp);
}}
}

if(UT_Open_W_Resistance == Yes)
{
if(Close[0]<SSSR_WUR_UT && Close[0]>SSSR_WDR_UT)
{
if(StopLoss > 0) _sl = Bid + StopLoss;
if(TakeProfit > 0) _tp = Bid - TakeProfit;
if(orders<MaxTrades)
{
openOrder(getLots(),MagicNumber,OP_SELL, _sl,_tp);
}}
}

if(UT_Open_T_Resistance == Yes)
{
if(Close[0]<SSSR_TUR_UT && Close[0]>SSSR_TDR_UT)
{
if(StopLoss > 0) _sl = Bid + StopLoss;
if(TakeProfit > 0) _tp = Bid - TakeProfit;
if(orders<MaxTrades)
{
openOrder(getLots(),MagicNumber,OP_SELL, _sl,_tp);
}}
}
}
//-------------------------------------------------------------------
//-------------------------------------------------------------------

}
}
//-------------------------------------------------------------------
//CODE FOR SELL FILTER HTF_HMA = HIGHT TIME FRAME HMA
//-------------------------------------------------------------------
if(((( HTF_SlowHMACurrent_0 + HTF_SlowHMAPrevious_1)/2 )-( HTF_FastHMACurrent_0 + HTF_FastHMAPrevious_1 )/2)> 0.001 ) // this is to compare segments between 0 (present bar) and 1(previous bar) // code by tomcat98
{

//-------------------------------------------------------------------
//-------------------------------------------------------------------
// BUY Signals Options
{
if(DT_Open_V_Support == Yes)
{
if(Close[0]<SSSR_VUS_DT && Close[0]>SSSR_VDS_DT)
{
if(StopLoss > 0) _sl = Ask - StopLoss;
if(TakeProfit > 0) _tp = Ask + TakeProfit;
if(orders<MaxTrades)
{
openOrder(getLots(),MagicNumber,OP_BUY, _sl,_tp);
}
}}

if(DT_Open_P_Support == Yes)
{
if(Close[0]<SSSR_PUS_DT && Close[0]>SSSR_PDS_DT)
{
if(StopLoss > 0) _sl = Ask - StopLoss;
if(TakeProfit > 0) _tp = Ask + TakeProfit;
if(orders<MaxTrades)
{
openOrder(getLots(),MagicNumber,OP_BUY, _sl,_tp);
}
}}

if(DT_Open_U_Support == Yes)
{
if(Close[0]<SSSR_UUS_DT && Close[0]>SSSR_UDS_DT)
{
if(StopLoss > 0) _sl = Ask - StopLoss;
if(TakeProfit > 0) _tp = Ask + TakeProfit;
if(orders<MaxTrades)
{
openOrder(getLots(),MagicNumber,OP_BUY, _sl,_tp);
}
}}

if(DT_Open_W_Support == Yes)
{
if(Close[0]<SSSR_WUS_DT && Close[0]>SSSR_WDS_DT)
{
if(StopLoss > 0) _sl = Ask - StopLoss;
if(TakeProfit > 0) _tp = Ask + TakeProfit;
if(orders<MaxTrades)
{
openOrder(getLots(),MagicNumber,OP_BUY, _sl,_tp);
}
}}

if(DT_Open_T_Support == Yes)
{
if(Close[0]<SSSR_TUS_DT && Close[0]>SSSR_TDS_DT)
{
if(StopLoss > 0) _sl = Ask - StopLoss;
if(TakeProfit > 0) _tp = Ask + TakeProfit;
if(orders<MaxTrades)
{
openOrder(getLots(),MagicNumber,OP_BUY, _sl,_tp);
}
}}
}
//-------------------------------------------------------------------
//-------------------------------------------------------------------

//-------------------------------------------------------------------
//-------------------------------------------------------------------
// SELL signals options
{
if(DT_Open_V_Resistance == Yes)
{
if(Close[0]<SSSR_VUR_DT && Close[0]>SSSR_VDR_DT)
{
if(StopLoss > 0) _sl = Bid + StopLoss;
if(TakeProfit > 0) _tp = Bid - TakeProfit;
if(orders<MaxTrades)
{
openOrder(getLots(),MagicNumber,OP_SELL, _sl,_tp);
}}
}

if(DT_Open_P_Resistance == Yes)
{
if(Close[0]<SSSR_PUR_DT && Close[0]>SSSR_PDR_DT)
{
if(StopLoss > 0) _sl = Bid + StopLoss;
if(TakeProfit > 0) _tp = Bid - TakeProfit;
if(orders<MaxTrades)
{
openOrder(getLots(),MagicNumber,OP_SELL, _sl,_tp);
}}
}

if(DT_Open_U_Resistance == Yes)
{
if(Close[0]<SSSR_UUR_DT && Close[0]>SSSR_UDR_DT)
{
if(StopLoss > 0) _sl = Bid + StopLoss;
if(TakeProfit > 0) _tp = Bid - TakeProfit;
if(orders<MaxTrades)
{
openOrder(getLots(),MagicNumber,OP_SELL, _sl,_tp);
}}
}

if(DT_Open_W_Resistance == Yes)
{
if(Close[0]<SSSR_WUR_DT && Close[0]>SSSR_WDR_DT)
{
if(StopLoss > 0) _sl = Bid + StopLoss;
if(TakeProfit > 0) _tp = Bid - TakeProfit;
if(orders<MaxTrades)
{
openOrder(getLots(),MagicNumber,OP_SELL, _sl,_tp);
}}
}

if(DT_Open_T_Resistance == Yes)
{
if(Close[0]<SSSR_TUR_DT && Close[0]>SSSR_TDR_DT)
{
if(StopLoss > 0) _sl = Bid + StopLoss;
if(TakeProfit > 0) _tp = Bid - TakeProfit;
if(orders<MaxTrades)
{
openOrder(getLots(),MagicNumber,OP_SELL, _sl,_tp);
}}
}
}
//-------------------------------------------------------------------
//-------------------------------------------------------------------
// Hedge Sell Signals Options
{
if(((( SlowHMACurrent_0 + SlowHMAPrevious_1)/2 )-( FastHMACurrent_0 + FastHMAPrevious_1 )/2)> 0.001 ) // this is to compare segments between 0 (present bar) and 1(previous bar) // code by tomcat98
{
{
if(DT_Hedge_Mode == Yes && DT_Hedge_V_Resistance == Yes) //HBHB= HMA FILTER SELL && HEDGE SELL
{
if(Close[0]<SSSR_VDS_DT)
{
if(StopLoss > 0) _sl = Bid + StopLoss;
if(TakeProfit > 0) _tp = Bid - TakeProfit;
if(orders<MaxTrades)
{
openOrder(getLots(),MagicNumber,OP_SELL, _sl,_tp);
}
}}

if(DT_Hedge_Mode == Yes && DT_Hedge_P_Resistance == Yes)
{
if(Close[0]<SSSR_PDS_DT)
{
if(StopLoss > 0) _sl = Bid + StopLoss;
if(TakeProfit > 0) _tp = Bid - TakeProfit;
if(orders<MaxTrades)
{
openOrder(getLots(),MagicNumber,OP_SELL, _sl,_tp);
}
}}

if(DT_Hedge_Mode == Yes && DT_Hedge_U_Resistance == Yes)
{
if(Close[0]<SSSR_UDS_DT)
{
if(StopLoss > 0) _sl = Bid + StopLoss;
if(TakeProfit > 0) _tp = Bid - TakeProfit;
if(orders<MaxTrades)
{
openOrder(getLots(),MagicNumber,OP_SELL, _sl,_tp);
}
}}

if(DT_Hedge_Mode == Yes && DT_Hedge_W_Resistance == Yes)
{
if(Close[0]<SSSR_WDS_DT)
{
if(StopLoss > 0) _sl = Bid + StopLoss;
if(TakeProfit > 0) _tp = Bid - TakeProfit;
if(orders<MaxTrades)
{
openOrder(getLots(),MagicNumber,OP_SELL, _sl,_tp);
}
}}

if(DT_Hedge_Mode == Yes && DT_Hedge_T_Resistance == Yes)
{
if(Close[0]<SSSR_TDS_DT)
{
if(StopLoss > 0) _sl = Bid + StopLoss;
if(TakeProfit > 0) _tp = Bid - TakeProfit;
if(orders<MaxTrades)
{
openOrder(getLots(),MagicNumber,OP_SELL, _sl,_tp);
}
}}}
}
}

}


}}


for(int cnt = 0 ;cnt<OrdersTotal();cnt++)
{
if(!OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES))
continue;

//--------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------
// CLOSE ORDERS
//--------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------
//HMA FILTER HTF_HMA
{
if(((( HTF_FastHMACurrent_0 + HTF_FastHMAPrevious_1)/2 )-( HTF_SlowHMACurrent_0 + HTF_SlowHMAPrevious_1 )/2)> 0.001 ) // this is to compare segments between 0 (present bar) and 1(previous bar) // code by tomcat98
{
//CHECK FOR CLOSE ORDERS BUY AT RESISTANCE
if(OrderType() == OP_BUY)
{
if(UT_Close_V_Resistance == Yes)
{
if(Close[0]<SSSR_VUR_UT && Close[0]>SSSR_VDR_UT)
{
closeOrder(OrderTicket(),9999);
if(DebugMode == Yes) Print("CLOSING AT V_RESISTANCE");
break;
} }

if(UT_Close_P_Resistance == Yes)
{
if(Close[0]<SSSR_PUR_UT && Close[0]>SSSR_PDR_UT)
{
closeOrder(OrderTicket(),9999);
if(DebugMode == Yes) Print("CLOSING AT P_RESISTANCE");
break;
} }

if(UT_Close_U_Resistance == Yes)
{
if(Close[0]<SSSR_UUR_UT && Close[0]>SSSR_UDR_UT)
{
closeOrder(OrderTicket(),9999);
if(DebugMode == Yes) Print("CLOSING AT U_RESISTANCE");
break;
} }

if(UT_Close_W_Resistance == Yes)
{
if(Close[0]<SSSR_WUR_UT && Close[0]>SSSR_WDR_UT)
{
closeOrder(OrderTicket(),9999);
if(DebugMode == Yes) Print("CLOSING AT W_RESISTANCE");
break;
} }

if(UT_Close_T_Resistance == Yes)
{
if(Close[0]<SSSR_TUR_UT && Close[0]>SSSR_TDR_UT)
{
closeOrder(OrderTicket(),9999);
if(DebugMode == Yes) Print("CLOSING AT T_RESISTANCE");
break;
} }
}

//CHECK FOR CLOSE ORDERS SELL AT SUPPORT

if(OrderType() == OP_SELL)
{
if(UT_Close_V_Support == Yes)
{
if(Close[0]<SSSR_VUS_UT && Close[0]>SSSR_VDS_UT)
{
closeOrder(OrderTicket(),9999);
if(DebugMode == Yes) Print("CLOSING AT V_SUPPORT");
break;
} }

if(UT_Close_P_Support == Yes)
{
if(Close[0]<SSSR_PUS_UT && Close[0]>SSSR_PDS_UT)
{
closeOrder(OrderTicket(),9999);
if(DebugMode == Yes) Print("CLOSING AT P_SUPPORT");
break;
} }

if(UT_Close_U_Support == Yes)
{
if(Close[0]<SSSR_UUS_UT && Close[0]>SSSR_UDS_UT)
{
closeOrder(OrderTicket(),9999);
if(DebugMode == Yes) Print("CLOSING AT U_SUPPORT");
break;
} }

if(UT_Close_W_Support == Yes)
{
if(Close[0]<SSSR_WUS_UT && Close[0]>SSSR_WDS_UT)
{
closeOrder(OrderTicket(),9999);
if(DebugMode == Yes) Print("CLOSING AT W_SUPPORT");
break;
} }

if(UT_Close_T_Support == Yes)
{
if(Close[0]<SSSR_TUS_UT && Close[0]>SSSR_TDS_UT)
{
closeOrder(OrderTicket(),9999);
if(DebugMode == Yes) Print("CLOSING AT T_SUPPORT");
break;
} }

}
}
}
//--------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------
//HMA FILTER HTF_HMA
{
if(((( HTF_SlowHMACurrent_0 + HTF_SlowHMAPrevious_1)/2 )-( HTF_FastHMACurrent_0 + HTF_FastHMAPrevious_1 )/2)> 0.001 ) // this is to compare segments between 0 (present bar) and 1(previous bar) // code by tomcat98
{
//CHECK FOR CLOSE ORDERS BUY AT RESISTANCE
if(OrderType() == OP_BUY)
{
if(DT_Close_V_Resistance == Yes)
{
if(Close[0]<SSSR_VUR_DT && Close[0]>SSSR_VDR_DT)
{
closeOrder(OrderTicket(),9999);
if(DebugMode == Yes) Print("CLOSING AT V_RESISTANCE");
break;
} }

if(DT_Close_P_Resistance == Yes)
{
if(Close[0]<SSSR_PUR_DT && Close[0]>SSSR_PDR_DT)
{
closeOrder(OrderTicket(),9999);
if(DebugMode == Yes) Print("CLOSING AT P_RESISTANCE");
break;
} }

if(DT_Close_U_Resistance == Yes)
{
if(Close[0]<SSSR_UUR_DT && Close[0]>SSSR_UDR_DT)
{
closeOrder(OrderTicket(),9999);
if(DebugMode == Yes) Print("CLOSING AT U_RESISTANCE");
break;
} }

if(DT_Close_W_Resistance == Yes)
{
if(Close[0]<SSSR_WUR_DT && Close[0]>SSSR_WDR_DT)
{
closeOrder(OrderTicket(),9999);
if(DebugMode == Yes) Print("CLOSING AT W_RESISTANCE");
break;
} }

if(DT_Close_T_Resistance == Yes)
{
if(Close[0]<SSSR_TUR_DT && Close[0]>SSSR_TDR_DT)
{
closeOrder(OrderTicket(),9999);
if(DebugMode == Yes) Print("CLOSING AT T_RESISTANCE");
break;
} }
}

//CHECK FOR CLOSE ORDERS SELL AT SUPPORT

if(OrderType() == OP_SELL)
{
if(DT_Close_V_Support == Yes)
{
if(Close[0]<SSSR_VUS_DT && Close[0]>SSSR_VDS_DT)
{
closeOrder(OrderTicket(),9999);
if(DebugMode == Yes) Print("CLOSING AT V_SUPPORT");
break;
} }

if(DT_Close_P_Support == Yes)
{
if(Close[0]<SSSR_PUS_DT && Close[0]>SSSR_PDS_DT)
{
closeOrder(OrderTicket(),9999);
if(DebugMode == Yes) Print("CLOSING AT P_SUPPORT");
break;
} }

if(DT_Close_U_Support == Yes)
{
if(Close[0]<SSSR_UUS_DT && Close[0]>SSSR_UDS_DT)
{
closeOrder(OrderTicket(),9999);
if(DebugMode == Yes) Print("CLOSING AT U_SUPPORT");
break;
} }

if(DT_Close_W_Support == Yes)
{
if(Close[0]<SSSR_WUS_DT && Close[0]>SSSR_WDS_DT)
{
closeOrder(OrderTicket(),9999);
if(DebugMode == Yes) Print("CLOSING AT W_SUPPORT");
break;
} }

if(DT_Close_T_Support == Yes)
{
if(Close[0]<SSSR_TUS_DT && Close[0]>SSSR_TDS_DT)
{
closeOrder(OrderTicket(),9999);
if(DebugMode == Yes) Print("CLOSING AT T_SUPPORT");
break;
} }

}
}
}

//TRAILING STOP
if(TrailingStopTrigger > 0)
{
if(OrderType() == OP_BUY)
{
if((
OrderStopLoss() < Bid - TrailingStopPips
|| OrderStopLoss() == 0) &&
Bid > OrderOpenPrice()+TrailingStopTrigger)
{
if(NormalizeDouble(OrderStopLoss(),Digits)!=NormalizeDouble(Bid - TrailingStopPips,Digits))
moveExitLevel(OrderTicket(),NormalizeDouble(Bid - TrailingStopPips,Digits),-1);

}
}
else if(OrderType() == OP_SELL)
{
if((
OrderStopLoss()==0 ||
OrderStopLoss() > Ask + TrailingStopPips)
&&
Ask < OrderOpenPrice()-TrailingStopTrigger)
{
if(NormalizeDouble(OrderStopLoss(),Digits)!=NormalizeDouble(Ask + TrailingStopPips,Digits))
moveExitLevel(OrderTicket(),NormalizeDouble(Ask + TrailingStopPips,Digits),-1);
}
}
}



}


}

//check if order with level is already opened
bool closeOrder(int ticket,double size)
{
if(!IsTradeAllowed() )
return (false);

int MAXRETRIES = 5;
int retries = 0;

if(!OrderSelect(ticket,SELECT_BY_TICKET,MODE_TRADES))return(false);

double lots = OrderLots();
if(size < lots)
{
lots = size;
}

int error;
if(OrderType() == OP_BUY)
{
while(!OrderClose(ticket,lots, NormalizeDouble(MarketInfo(Symbol(),MODE_BID),Digits), 0, Red))
{

error = GetLastError();

if(error>1)
Print("OrderClose failed with error #",error);

Sleep(1000);

RefreshRates();

if(retries >= MAXRETRIES)
return(false);
else
retries++;
}

}
else
{
while(!OrderClose(ticket, lots, NormalizeDouble(MarketInfo(Symbol(),MODE_ASK),Digits), 0, Red))
{
error = GetLastError();

if(error>1)
Print("OrderClose failed with error #",error);

Sleep(1000);

RefreshRates();

if(retries >= MAXRETRIES)
return(false);
else
retries++;
}

}

return (true);
}
double getLots()
{
double Lot = 0;

if(UseAutoLot == Yes)
{

Lot = NormalizeDouble(AccountEquity() * AutoLot/10000/(MaxTrades), 2);
if(Lot > MaxLot) Lot = MaxLot;
}

else
{
Lot = StaticLots;
}

return(Lot);
}
bool openOrder(double _lots,int _magic,int _type, double __sl,double __tp, string _description = "" )
{


while(IsTradeContextBusy())Sleep(1000);
if(!IsTradeAllowed())
{
Print("TRADE NOT ALLOWED");
return (false);
}

if(TimeCurrent()<=lastOrderTime+(SleepMinutes*60))
return(false);


int error = 0;
int ticket = 0;
int retries = 0;

while(true)
{
RefreshRates();

double orderOpenPrice = 0;
switch(_type)
{
case OP_SELL:
{
orderOpenPrice = MarketInfo(Symbol(),MODE_BID);
ticket = OrderSend(Symbol(),OP_SELL,_lots,orderOpenPrice,0,0,0, _description,_magic,0,Red);
}
break;
case OP_BUY:
{
orderOpenPrice = MarketInfo(Symbol(),MODE_ASK);
ticket = OrderSend(Symbol(),OP_BUY,_lots,orderOpenPrice,0,0,0, _description,_magic,0,Green);
}
break;
}

if(retries>4)break;

if(ticket<=0)
{
error=GetLastError();
Print("ORDER ERROR:"+ (string)error);
retries++;
}
else
{
lastOrderTime = TimeCurrent();

if(__tp > 0)
moveExitLevel(ticket,__tp,1);

if(__sl > 0)
moveExitLevel(ticket,__sl,-1);

return (true);
}
}
return (false);
}

bool moveExitLevel(int ticket,double newValue,int type,int _sleep = 1/*in seconds*/,int _retries = 5)
{
//type 1= takeprofit, type =-1 stoploss
if(!IsTradeAllowed()) return (0);

if(!OrderSelect(ticket,SELECT_BY_TICKET,MODE_TRADES))
{
Print("ERROR : order "+((string)ticket)+" not found");
return(0);
}
string _orderSymbol = OrderSymbol();

int error;
int MAXRETRIES = _retries;
int retries = 0;

if(type == -1)
{
if(MathAbs(MarketInfo(_orderSymbol,MODE_ASK)-newValue)/MarketInfo(_orderSymbol,MODE_POINT) < MarketInfo(_orderSymbol,MODE_STOPLEVEL))
{
return(0);
}

while(!OrderModify(ticket,OrderOpenPrice(), newValue, OrderTakeProfit(), 0,CLR_NONE))
{
error = GetLastError();
if(error>1)
{
Print("MoveSL failed with error #",error," CurrentSL ",OrderStopLoss()," NewSL ",newValue);
}
Sleep(_sleep*1000);
if(retries >= MAXRETRIES)
return(0);
else
retries++;
RefreshRates();
}
}
else if(type == 1)
{
if(MathAbs(MarketInfo(_orderSymbol,MODE_BID)-newValue)/MarketInfo(_orderSymbol,MODE_POINT) < MarketInfo(_orderSymbol,MODE_STOPLEVEL))
{
return(0);
}
while(!OrderModify(ticket,OrderOpenPrice(), OrderStopLoss(), newValue, 0,CLR_NONE))
{
error = GetLastError();
if(error>1)
{
Print("MoveTP failed with error #",error," CurrentTP ",OrderTakeProfit()," NewTP ",newValue);
}
Sleep(_sleep*1000);
if(retries >= MAXRETRIES)
return(0);
else
retries++;
RefreshRates();
}
}
return(1);
}
void lineTrend(string name,datetime tfrom, double pfrom ,datetime tto, double pto , int width, color Col)
{


ObjectDelete(name);
ObjectCreate(name, OBJ_TREND, 0, tfrom, pfrom,tto, pto);


ObjectSet(name, OBJPROP_STYLE, STYLE_SOLID);

ObjectSet(name, OBJPROP_COLOR, Col);
ObjectSet(name,OBJPROP_WIDTH,width);
ObjectSet(name,OBJPROP_RAY,0);

}
void label(string text, color Color = Aqua, string font = "Verdana")
{
string name = "XXX"+(string)labelId;

ObjectCreate(name, OBJ_LABEL, 0, 0, 0);
ObjectSetText(name,text, 10, font, Color);
ObjectSet(name, OBJPROP_CORNER, 4);
ObjectSet(name, OBJPROP_XDISTANCE, 10);
ObjectSet(name, OBJPROP_YDISTANCE, y);

labelId++;
y+=20;
}
void resetObjects()
{
while(true)
{
bool deleted = false;

for(int i = 0;i<ObjectsTotal();i++)
{
if(StringFind(ObjectName(i),"TLLXYZ")!=-1)
{
ObjectDelete(ObjectName(i));
deleted = true;
}
}

if(!deleted)break;
}
labelId =0;
y = 20;

}
bool tradeTime()
{
if(TradingEntryTime == No) return(true);

bool result = false;


datetime SessionStart = StrToTime((string)TimezoneStartHour+":"+ (string)TimezoneStartMinute);
datetime SessionEnd = StrToTime((string)TimezoneEndHour+":"+(string)TimezoneEndMinute);

datetime ctime = TimeCurrent()-((60*60)*GMTOffsetOfBroker);

if ( TimezoneStartHour < TimezoneEndHour)
result = ctime >= SessionStart && ctime < SessionEnd;
else
if ( TimezoneStartHour > TimezoneEndHour)
result = (ctime > SessionStart && TimeHour(ctime) < 24)
||(TimeHour(ctime) >= 0 && ctime < SessionEnd);

return(result);
}
int countOrders(int type)
{
int oc = 0;
for(int cnt = 0 ;cnt<OrdersTotal();cnt++)
{
if(!OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES))continue;

if(OrderMagicNumber() == MagicNumber && (OrderType() == type || type == -1))
oc+=1;
}
return(oc);

a friend found v3 he testing now haha

We can create new vertion!!

We can use Market profile indi with SSSR

- extract median from last 500 or n days , and the box price levels from latest day high and low from market profile
- make them work with SSSR

only buy if median is inside box of supports for sssr
only sell if median is inside box of resistances for sssr

buy breakout of box of market profile if level inside sssr resistance
sell breakout of box of market profile if level inside sssr support

who wants to code hhahaha is so boring coding

Hi Danielant, good to see yo are going to continue developing the EA. Hope your new ideas will work,
Andres

Ok while we wait for coder, im playing with code posted with gold, as the most difficult is how to setup all those variables, would be perfect if we find a way to setup all together... but is imposible on mt4, we have to play look a way to setup... not easy task.

So i was doing memmory thinking how was my idea to do that...

i remember i used day chart to set each items then i tested on lower tf if fits...

code without hma on gold m15 gives this.

so first

on day chart
1set uptrend options
2set dntrend option
3set hedge up options
4set hedge dn options
5 set sl tp
6 test