//————————————————————-
// Indo Run EA 1.5
//————————————————————-
// by expat1967 ;) Cheers
#property copyright “expat&&Indo Investasi Members”
#property link “expat&&Indo Investasi Forum”
#include
#include
// exported variables
extern string Menu = “Indo Run Setup”;
extern string EAName = “”; //Comment for your orders, you might better leave it empty ;)
extern bool IndoRunLabelOn = true; //Switches Chart Label on/off
extern string MagicNumber = “Random Magic will overide manual set Magic Number”;
extern int Magic = 128738; //Order Magic Number
extern bool UseRandomMagic = false; //Switches the Random Magic Number on/off
extern int RandomMagicLower = 100000; //Sets the lower Magic Number boundry
extern int RandomMagicUpper = 200000; //Sets the upper Magic Number boundry
extern string DayFilter = “Select the days for Indo Run to trade”;
extern bool Monday = true; // Selecting a day true/false will hold the EA off trading that day if no trades are open
extern bool Tuesday = true; // Overides day filter if trades are open (Basket)
extern bool Wednesday = true;
extern bool Thursday = true;
extern bool Friday = true;
extern bool Saturday = true;
extern bool Sunday = true;
extern bool TradeMonthEnd = true;
extern int MonthEndOffset = 3; //Offset to define the last trading day of a month (31 – Offset)
extern bool TradeFirstDayOffMonth = true;
extern int DayOffset = 0; //Per default the Offset is 0 thus the 1st of a month is filtered
extern double GMTOffset = 0;
extern bool TradeNFP = true; //Trade Day of Non Farm Employment
extern bool TradeMondayAfterNFP = true; //Trade Monday till US Session after Non Farm Employment / TradeNFP must be set to true
extern bool TradeADP = true; //Trade Day of ADP Non Farm Employment
extern string HourFilter = “Select the Trading Hours or set to 24h”;
extern bool Trading24h = true;
extern int HoursFrom = 10; //Start Trading Hour Broker Time (Standad Settings GMT), the EA overides time if trades are open (Basket)
extern int HoursTo = 6; //Stop Trading Hour Broker Time Standard Setting GMT), the EA overides time if trades are open (Basket)
extern string Session_Filter = “Only in 24 Mode: Use both Session Filter together only!”;
extern string Session_Filter1 = “Filters per default London Session (GMT)!”;
extern bool SessionFilter1 = false; //Session Filter Settings in GMT / Use only in combination with SessionFilter 2
extern double SF1Hour_On = 5;
extern double SF1MinuteOn =45;
extern double SF1Hour_Off = 9;
extern double SF1MinuteOff = 0;
extern string Session_Filter2 = “Filters per default NY Session (GMT)!”;
extern bool SessionFilter2 = false; //Session Filter Settings in GMT / Use only in combination with SessionFilter 1
extern double SF2Hour_On = 11;
extern double SF2MinuteOn =45;
extern double SF2Hour_Off = 17;
extern double SF2MinuteOff = 30;
extern string Info9 = “News Filter Setup”;
extern bool AvoidNews = true; //Switches News Filter on/off
extern bool High_Impact=true;
extern int MinsUntilNextHighNews=90;
extern int MinsSincePrevHighNews=90;
extern bool Medium_Impact=true;
extern int MinsUntilNextMediumNews=90;
extern int MinsSincePrevMediumNews=90;
extern bool Low_Impact=false;
extern int MinsUntilNextLowNews=60;
extern int MinsSincePrevLowNews=60;
extern string Info10 = “News Currency Filter”; //Select the Currency which News should be filtered
extern bool USD = true;
extern bool EUR = false;
extern bool GBP = true;
extern bool JPY = false;
extern bool AUD = false;
extern bool CAD = false;
extern bool CHF = false;
extern bool NZD = false;
extern int TSD_CalendarID = 4; // TSD News Calendar ID reference on the TSD Homepage
extern string TSD_Calendar_URL = “http://calendar.forex-tsd.com/calendar.php?csv=1&date=”;
extern string Info5 = “Main Order Setup”;
extern string PAO = ” ProfitAllOrder will calculate automatically while the Lotssize is changed!”;
extern double ProfitAllOrder = 15; //Cumulated Sell Order Take Profit in Account Currency based on 0.1 Lotsize!!!
extern bool FixedProfitAO = false; // If true, ProfitAllOrder amount set will be used only/Have to be set to tru while using Martingale!!!
extern bool ADVProfitMode = false; //Advanced Profit Modue which reduces the Profit Target on increasing opened Orders in the Basket
extern bool ATRProfitMode = false; //This Mode will take the Profit (>=ATR Profit) while the ATR is Filtering on open trades
extern double ATRProfit = 4; //This value does not adjusts automatically while the Lotsize is changed.
extern bool ADVATRProfit = false; //Overrides ATRProfit set and will apply ProfitAllOrders/ADVATRProfitx
extern double ADVATRProfitx = 3; //ProfitAllOrders/ADVATRProfitx
extern bool DynamicProfit = false; //If true, when ProfitAllOrder limit is reached the profit will trail by the defined step
extern double DynamicProfitStep = 1; //Inc of the ProfitAllOrder value
extern bool Trailing = false; //If true, Profit will be trailed while if Drawdown as set in TrailingStop and BE
extern int OrderTreshold = 20; //Number of open trades for the trailing to start
extern bool Breakeven = false; //Breakeven Profit upon Order Treshold. Requires Trailing to be set to true
extern double BE = 0; //Breakeven in Account Currency
extern bool OrderTrailing = false; //If true Order Profits will be trailed downwards while in DD after Breakeven
extern double TrailingStop = 15; //Profit of Account Currency on which the Profit is reduced/trailed per open Order after Breakeven.
int OpenOrdersLimit = 0; //Limits the number of open orders
extern bool DeletePOMode = true; // Bug: if false Sell Open Orders are not registered and counted
extern bool ReverseOrder = false; //Reverse/Hedging Trades from a defined Treshold of trades onwards
extern int OpenOrderTreshold = 10; //Reverse/Hedging Trade Treshold
extern double ReverseOrderLotDiv = 2; //Lot divider for Reverse/Hedging Trades (Lot/ReverseOrderLotDiv)
extern bool ReversalContBasket = true; //Continue Basket while Orders are reversed in addition
extern int SingleOrderSL = 0; //Stop Loss of each individual Order in Pips
extern int SingleOrderTP = 0; //Take Profit of each individual Order in Pips
extern bool ADVOffsetMode = false; //If false Pending Orders are placed on the current ASK/Bid Price
extern bool ATRStepOn = false; //If true the step value/price offset is linked to the current ATRPips value
extern bool ATRPipsToStep = false; //If true the ATRPips value will be used as Step/Price Offset
extern int PriceOffset = -16; //Step/Gap in Pips where Pending Order is placed to current price basic
extern bool StepFactorOn = false; //Factor which increases the Step per Order
extern int StepFactor = 10; //ProfitOffset*(OrderCounter/StepFactor+1)
extern int PriceOffset1 = 0; ////Step/PriceOffset added in Low Range ATR while ATRStepOn is set to true
extern int PriceOffset2 = -1; //Step/PriceOffset added in Mid Range ATR while ATRStepOn is set to true
extern int PriceOffset3 = -2; //Step/PriceOffset added in High Range ATR while ATRStepOn is set to true
extern double Lot = 0.1; //Single Order Lotsize / If FixedProfitAO = false Profit Target will be calculated automatically to the Profit Target set on 0.1 base (0.1 Lot = 15$ standard setting)
extern int Slippage=4; //Price Change in Pips allowed during Order Processing
extern string AutomaticLots1 = “Automatic Lotsize based on Account Balance!”;
extern string AutomaticLots2 = “ProfitAllOrder gets adjusted automatically!”;
extern bool AutoLotSize = false; //Automatic Lotsize based on Account Balance (Account Balance/300*MinLots)
extern double Risk = 2; //”Risk Factor on which the Lotsize increases
extern double MinLots = 0.01; //minimum Lotsize only used when Autolotsize is activated
extern bool KLotSize = false; // if true Lot Size will double every 10K+
extern bool DoubleLots = false; //Doubles the Lotsize in the Asian Session
extern bool Martingale = false; //Need to set FixedProfitAO=true!!!!
extern double LotFactor = 1.4; //Increasing Factor of Martingale Lotsize
extern double MartingaleMaxLot = 0.5; //Limit of Losize of Martingale!!!
extern bool DoubleBasket = false; //if true the EA will trade with two Order Baskets (First Basket opens Trade second Basket comes online in addition)
extern bool TripleBasket = false; //if true the EA will trade with three Order Baskets (Second Basket opens Trade third Basket comes online in addition)
extern string Timed_Stop = “Stops Trading and closes all trades at selected time of a day!”;
extern bool TimedStop = false; //Switches Time to close all open orders once a day on/off
extern int StopHour = 14; //Timed Stop Hour GMT
extern int StopMinute = 0; //Timed Stop Minute
extern string ATR_Filter = “ATR Filter selection and setup!”;
extern bool ATROn = true; //Switches ATR Filter on/off
extern bool FilterMod = false;
extern int ATR_Period1 = 7;
extern int ATR_Period2 = 7;
extern int ATR_Period3 = 7;
extern double ATRShift1 = 0.0;
extern double ATRShift2 = 3.0;
extern double ATRShift3 = 5.0;
extern double ATRUpLimit1 = 13.0;
extern double ATRDnLimit1 = 7.0;
extern double ATRUpLimit2 = 21.0;
extern double ATRDnLimit2 = 16.0;
extern double ATRUpLimit3 = 26.0;
extern double ATRDnLimit3 = 24.0;
extern string Info15 = “CCI Filter Settings”;
extern bool CCIFilterOn = false;
extern double CCIPeriod1 = 14;
extern double CCIPeriod2 = 14;
extern double CCIShift1 = 0;
extern double CCIShift2 = 5;
extern double CCICurrentUp = 65;
extern double CCICurrentDown = -65;
extern double CCIPreviousUp = 75;
extern double CCIPreviousDown = -75;
extern string Info16 = “Momentum Filter Settings”;
extern bool MomentumFilterOn = false;
extern double MomentumPeriod1 = 3;
extern double MomentumPeriod2 = 3;
extern double MomentumShift1 = 0;
extern double MomentumShift2 = 3;
extern double MomentumCurrentUp = 100.1;
extern double MomentumCurrentDown = 99.9;
extern double MomentumPreviousUp = 100.2;
extern double MomentumPreviousDown = 99.8;
extern string Info17 = “RSI Filter Settings”;
extern bool RSIFilterOn = false;
extern double RSIPeriod1 = 3;
extern double RSIPeriod2 = 3;
extern double RSIShift1 = 0;
extern double RSIShift2 = 3;
extern double RSICurrentUp = 51;
extern double RSICurrentDown = 49;
extern double RSIPreviousUp = 53;
extern double RSIPreviousDown = 47;
extern string Info18 = “MA Filter Settings”;
extern bool MAFilterOn = false;
extern double MAPeriod1 = 3;
extern double MAPeriod2 = 3;
extern double MAIShift1 = 0;
extern double MAIShift2 = 0;
extern double MAMethod = 0;
extern double MAShift1 = 0;
extern double MAShift2 = 3;
extern double MACurrentUp = 0.00025;
extern double MACurrentDown = 0.00025;
extern double MAPreviousUp = 0.0005;
extern double MAPreviousDown = 0.0005;
extern string Info19 = “Envelopes Filter Settings”;
extern bool EnvelopesFilterOn = false;
extern int EnvelopesTimeFrame = 0; //Indicator timeframe in minutes (0 = current chart timeframe)
extern int EnvelopesMAPeriod1 = 14;
extern int EnvelopesMAPeriod2 = 14;
extern int EnvelopesMAMethod = 0;
extern int EnvelopesMAShift1 = 0;
extern int EnvelopesMAShift2 = 0;
extern int EnvelopesAppliedPrice = 0;
extern double EnvelopesDeviation = 0.1; //Sets the distance/deviation of the upper and lower indicator line
extern int EnvelopesShift1 = 0;
extern int EnvelopesShift2 = 0;
extern string Info20 = “Specific Order and Emergency Functions”;
extern bool DeletePOATR = true; // Switch to delete all pending orders while ATR is active
extern bool DeleteOrderATR = false; // Switch to close all open orders while ATR is active (disabled due to current strategy set
extern string Stop_Out = “Closes all trades in basket on cummulated Profit/Loss!”;
extern bool LossStopOutOn = false; //Switches Cumulated Loss Stop Out On on/off
extern int LossStopOut = -5000; // Cumulated Loss in Account Currency which will close all open orders
extern string CAT = “!!!Closes all trades in basket when true!!!”;
extern bool CloseAllTrades = false; // Closes all open orders
// local variables
double PipValue=1; // this variable is here to support 5-digit brokers
bool Terminated = false;
string LF = “\n”; // use this in custom or utility blocks where you need line feeds
int NDigits = 4; // used mostly for NormalizeDouble in Flex type blocks
int ObjCount = 0; // count of all objects created on the chart, allows creation of objects with unique names
bool FirstTime33 = false;
bool FirstTime35 = false;
int Today6 = -1;
int Count32 = 0;
double dblProfit=0;
string ATR = “”;
string Trading = “”;
int OrderCounter =0; //counts open orders including pending orders
bool Overide = false;
int Hour1 = 1;
int Minute1 = 2;
string MagicChange = “Waiting…”;
string RMStatus = “Waiting…”;
bool Buffer = true;
double ProfitAllOrders = 0;
double TrailingStops =0;
string SessionFilter = “Waiting…”;
double ATRPips;
double ATRPrePips1;
double ATRPrePips2;
string Zone1;
string Zone2;
string Zone3;
string Zone4;
string Zone5;
string AutoLot;
string FilterMods;
bool AsianSession = false;
double Lots;
string Double_Lot;
double TotalTradeLots;
double BuyLots;
double SellLots;
bool NewsFilter;
string Filter;
string NewsF;
string CCIStatus;
string MomentumStatus;
string RSIStatus;
string MAStatus;
string EnvelopeStatus;
bool ATRProfitTrigger=false;
double MagicBuffer;
double DDBuffer=0;
string Basket=”1″;
double TrailingProfit[4];
int BasketTrailing=1;
bool BuyBasket;
bool SellBasket;
datetime NewsTimes[1000];
int NewsRatings[1000];
int NewsTotal;
bool EnableFileErrorLogging = false;
int logHandle=-1;
//*******************************************************************************************************
int init()
{
NDigits = Digits;
ObjectsDeleteAll(); // clear the chart
// GlobalVariableSet(“OldBalance”, AccountBalance());
Comment(“”); // clear the chart
if ((Buffer == true)&&(!IsTesting()))
{
ReadMagic();
Buffer=false;
}
MagicBuffer=Magic;
}
// Expert start
//*******************************************************************************************************
int start()
{
if (Bars < 10)
{
Comment(“Not enough bars!”);
return (0);
}
if (Terminated == true)
{
Comment(“EA Terminated!”);
return (0);
}
OnEveryTick24();
}
//*******************************************************************************************************
void OnEveryTick24()
{
if (true == false && true) PipValue = 10;
if (true && (NDigits == 3 || NDigits == 5)) PipValue = 10;
if(TripleBasket||DoubleBasket)
{
TripleBasket();
}
else
{
Sequence();
}
}
//******************************************************************************************************
void Sequence()
{
ReadATR();
News();
CCI();
Momentum();
RSI();
MA();
Envelopes();
Filter();
if (CloseAllTrades == false)
{
LotSize();
OnceAnHour1();
WeekdayFilter23();
AtCertainTime6();
}
PrintInfoToChart32();
CloseOrderIf21();
}
//******************************************************************************************************
bool MonthEnd(string symb, int year1, int month1, int day1, int ofs)
{
if (!TradeMonthEnd)
{
if (day1 > (31 – ofs)) return(false);
if (month1 == 2 && day1 > (29 – ofs)) return(false);
}
return(true);
}
//******************************************************************************************************
bool MonthFirst(string symb, int year1, int month1, int day1, int ofs)
{
if (!TradeFirstDayOffMonth)
{
if (day1 == 1 – ofs) return(false);
}
return(true);
}
//*******************************************************************************************************
bool NFP(string symb, int year1, int month1, int day1, int ofs)
{
if(!TradeNFP)
{
if(!TradeMondayAfterNFP)
{
if(DayOfWeek()==0&&day1>3&&day1<11)return(false);
if(DayOfWeek()==1&&day1>4&&day1<12)return(false);
}
if(DayOfWeek()==5&&day1>1&&day1<9)return(false);
}
return(true);
}
//*******************************************************************************************************
bool ADP(string symb, int year1, int month1, int day1, int ofs)
{
if(!TradeADP)
{
if((DayOfWeek()==3&&day1>=1&&day1<=8)||(DayOfWeek()==3&&day1==30))return(false);
}
return(true);
}
//*******************************************************************************************************
void WeekdayFilter23()
{
double GMT_Hour;
int servertime = TimeCurrent();
int GMT_time = servertime – 3600.0 * GMTOffset;
if (((Monday && DayOfWeek() == 1) || (Tuesday && DayOfWeek() == 2) || (Wednesday && DayOfWeek() == 3) ||
(Thursday && DayOfWeek() == 4) || (Friday && DayOfWeek() == 5) || (Saturday && DayOfWeek() == 6) || (Sunday && DayOfWeek() == 0))
&&(MonthEnd(Symbol(), TimeYear(GMT_time), TimeMonth(GMT_time), TimeDay(GMT_time), MonthEndOffset))
&&(MonthFirst(Symbol(), TimeYear(GMT_time), TimeMonth(GMT_time), TimeDay(GMT_time), DayOffset))
&&(NFP(Symbol(), TimeYear(GMT_time), TimeMonth(GMT_time), TimeDay(GMT_time), 0))
&&(ADP(Symbol(), TimeYear(GMT_time), TimeMonth(GMT_time), TimeDay(GMT_time), 0)))
{
Overide = false;
HoursFilter22();
}
else
{
if ((!IfOrderDoesNotExist(1))&&(!IfOrderDoesNotExist(0)))
{
Trading = “Not Trading!”;
DeletePendingOrder(2);
DeletePendingOrder(3);
if(!MonthEnd(Symbol(), TimeYear(GMT_time), TimeMonth(GMT_time), TimeDay(GMT_time), MonthEndOffset))
{
Trading = “Not Trading Months End!”;
}
if(!MonthFirst(Symbol(), TimeYear(GMT_time), TimeMonth(GMT_time), TimeDay(GMT_time), DayOffset))
{
Trading = “Not Trading 1st Day/Month!”;
}
if(!NFP(Symbol(), TimeYear(GMT_time), TimeMonth(GMT_time), TimeDay(GMT_time), 0))
{
Trading = “Not Trading NFP!”;
}
if(!NFP(Symbol(), TimeYear(GMT_time), TimeMonth(GMT_time), TimeDay(GMT_time), 0))
{
Trading = “Not Trading ADP!”;
}
}
else
{
Overide = true;
HoursFilter22();
}
}
}
//*******************************************************************************************************
void HoursFilter22()
{
int datetime800 = TimeCurrent();
int hour0 = TimeHour(datetime800);
datetime currTime = TimeCurrent();
double SF1HourOn = SF1Hour_On + GMTOffset;
double SF1HourOff = SF1Hour_Off + GMTOffset;
double SF2HourOn = SF2Hour_On + GMTOffset;
double SF2HourOff = SF2Hour_Off + GMTOffset;
datetime fromTime1 = StrToTime(DoubleToStr(SF1HourOn,0)+”:”+DoubleToStr(SF1MinuteOn,0));
datetime toTime1 = StrToTime(DoubleToStr(SF1HourOff,0)+”:”+DoubleToStr(SF1MinuteOff,0));
datetime fromTime2 = StrToTime(DoubleToStr(SF2HourOn,0)+”:”+DoubleToStr(SF2MinuteOn,0));
datetime toTime2 = StrToTime(DoubleToStr(SF2HourOff,0)+”:”+DoubleToStr(SF2MinuteOff,0));
int Hours_To = HoursTo + GMTOffset;
int Hours_From = HoursFrom + GMTOffset;
if (toTime2 > fromTime1 && (currTime = toTime2))
{
AsianSession = true;
}
else
{
AsianSession = false;
}
if (((Hours_From = Hours_From && hour0 < Hours_To) ||
(Hours_From > Hours_To && (hour0 = Hours_From)))&& (Trading24h == false))
{
Trading = “Trading”;
CheckLastOrderType33();
LimitOpenOrders28();
CheckLastOrderType35();
}
else
{
if ((Trading24h == false)&&((!IfOrderDoesNotExist(1))&&(!IfOrderDoesNotExist(0))))
{
Trading = “Not Trading!”;
DeletePendingOrder(2);
DeletePendingOrder(3);
}
else
{
if (Trading24h == false)
{
Trading = “Overide Hour/Day Filter”;
CheckLastOrderType33();
LimitOpenOrders28();
CheckLastOrderType35();
}
}
}
if (Trading24h == true)
{
if (Overide == true)
{
Trading = “Overide Hour/Day Filter”;
}
else
{
Trading = “Trading 24h”;
}
if (((SessionFilter1 == true) && (fromTime1 < toTime1 && (currTime = toTime1)))
&& ((SessionFilter2 == true) && (fromTime2 < toTime2 && (currTime = toTime2))))
//change && to || to use Filters seperate!
{
SessionFilter = “Session opened for trading!”;
CheckLastOrderType33();
LimitOpenOrders28();
CheckLastOrderType35();
}
else
{
if (((SessionFilter1 == true)||(SessionFilter2 == true))&&((!IfOrderDoesNotExist(1)) && (!IfOrderDoesNotExist(0))))
{
SessionFilter = “Session filtered!”;
DeletePendingOrder(2);
DeletePendingOrder(3);
}
else
{
if ((SessionFilter1 == true)||(SessionFilter2 == true))
{
SessionFilter = “Session Overide!”;
CheckLastOrderType33();
LimitOpenOrders28();
CheckLastOrderType35();
}
}
}
if ((SessionFilter1 == false)&&(SessionFilter2 == false))
{
SessionFilter = “Sessions not filtered!”;
CheckLastOrderType33();
LimitOpenOrders28();
CheckLastOrderType35();
}
}
}
//*******************************************************************************************************
void CloseOrderIf21()
{
int POS=0;
bool boolTerm=false;
dblProfit=0;
RefreshRates();
while(boolTerm==false)
{
if(OrderSelect(POS,SELECT_BY_POS))
{
if(OrderMagicNumber()==Magic) dblProfit=dblProfit+OrderProfit();
POS++;
}
else
boolTerm=true;
}
if ((!DynamicProfit&&dblProfit>= Profit())||(dblProfit<=LossStopOut&&LossStopOutOn==true)||CloseAllTrades==true)
{
CloseOrder(1);
CloseOrder(0);
}
if (DynamicProfit)
{
while(dblProfit-Profit()>DynamicProfitStep&&dblProfit-TrailingProfit[BasketTrailing]>DynamicProfitStep)TrailingProfit[BasketTrailing]=TrailingProfit[BasketTrailing]+DynamicProfitStep;
if(dblProfit=Profit())
{
CloseOrder(1);
CloseOrder(0);
TrailingProfit[BasketTrailing]=0;
}
if(ATRProfitMode&&ATRProfitTrigger&&dblProfit>=Profit())
{
CloseOrder(1);
CloseOrder(0);
TrailingProfit[BasketTrailing]=0;
}
}
return(0);
}
//*******************************************************************************************************
void LimitOpenOrders28()
{
int count = 0;
int z = 0;
for (int i=OrdersTotal()-1; i >= 0; i–)
if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
{
if (OrderSymbol() == Symbol())
if (OrderMagicNumber() == Magic)
{
count++;
}
}
else
{
Print(“OrderSend() error – “, ErrorDescription(GetLastError()));
}
if ((count < OpenOrdersLimit)||(OpenOrdersLimit==0))
{
SendOrder();
}
if ((!IfOrderDoesNotExist(1))&&(!IfOrderDoesNotExist(0)))
{
count = 0;
OrderCounter = count;
}
else
{
if (DeletePOMode == false)
{
z = 2;
}
else
{
z = 1;
}
count = count – z;
OrderCounter = count;
}
}
//*******************************************************************************************************
bool ReadATR()
{
Zone1 = “Closed!”;
Zone2 = “Closed!”;
Zone3 = “Closed!”;
Zone4 = “Closed!”;
Zone5 = “Closed!”;
double point=Point;
if (point==0.00001) point=0.0001;
else if (point==0.001) point=0.01;
ATRPips =MathRound(iATR(Symbol(),PERIOD_M15,ATR_Period1,ATRShift1) / point);
ATRPrePips1 =MathRound(iATR(Symbol(),PERIOD_M15,ATR_Period2,ATRShift2) / point);
ATRPrePips2 =MathRound(iATR(Symbol(),PERIOD_M15,ATR_Period3,ATRShift3) / point);
if(ATROn)
{
if (FilterMod == true)
{
FilterMods = “Modified!”;
if (ATRPrePips1 >= ATRDnLimit1 && ATRPrePips1 <= ATRUpLimit1
&& ATRPrePips2 >= ATRDnLimit1 && ATRPrePips2 <= ATRUpLimit1
&& ATRPips >= ATRDnLimit1 && ATRPips <= ATRUpLimit1)
{
ATR = “ATR not filtering!”;
Zone1 = “Open!”;
return(1);
}
if (ATRPrePips1 >= ATRDnLimit2 && ATRPrePips1 <= ATRUpLimit2
&& ATRPrePips2 >= ATRDnLimit2 && ATRPrePips2 <= ATRUpLimit2
&& ATRPips >= ATRDnLimit2 && ATRPips <= ATRUpLimit2)
{
ATR = “ATR not filtering!”;
Zone2 = “Open!”;
return(1);
}
if (ATRPrePips1 >= ATRDnLimit3 && ATRPrePips1 <= ATRUpLimit3
&& ATRPrePips2 >= ATRDnLimit3 && ATRPrePips2 <= ATRUpLimit3
&& ATRPips >= ATRDnLimit3 && ATRPips <= ATRUpLimit3)
{
ATR = “ATR not filtering!”;
Zone3 = “Open!”;
return(1);
}
if (ATRPrePips1 >= ATRDnLimit2 && ATRPrePips1 <= ATRUpLimit2
&& ATRPrePips2 >= ATRDnLimit2 && ATRPrePips2 <= ATRUpLimit2
&& ATRPips >= ATRDnLimit1 && ATRPips <= ATRUpLimit1)
{
ATR = “ATR not filtering!”;
Zone4 = “Open!”;
return(1);
}
if (ATRPrePips1 >= ATRDnLimit1 && ATRPrePips1 <= ATRUpLimit1
&& ATRPrePips2 >= ATRDnLimit2 && ATRPrePips2 <= ATRUpLimit2
&& ATRPips >= ATRDnLimit1 && ATRPips <= ATRUpLimit1)
{
ATR = “ATR not filtering!”;
Zone5 = “Open!”;
return(1);
}
}
else
{
FilterMods = “Standard!”;
if (ATRPrePips1 >= ATRDnLimit1 && ATRPrePips1 = ATRDnLimit1 && ATRPrePips2 = ATRDnLimit1 && ATRPips <= ATRUpLimit1 )
{
ATR = “ATR not filtering!”;
Zone1 = “Open!”;
return(1);
}
if (ATRPrePips1 >= ATRDnLimit2 && ATRPrePips1 = ATRDnLimit2 && ATRPrePips2 = ATRDnLimit2 && ATRPips <= ATRUpLimit2 )
{
ATR = “ATR not filtering!”;
Zone2 = “Open!”;
return(1);
}
if (ATRPrePips1 >= ATRDnLimit3 && ATRPrePips1 = ATRDnLimit3 && ATRPrePips2 = ATRDnLimit3 && ATRPips <= ATRUpLimit3 )
{
ATR = “ATR not filtering!”;
Zone3 = “Open!”;
return(1);
}
}
ATR = “ATR filtering!”;
return(0);
}
if (!ATROn)
{
ATR = “ATR Filter off!”;
FilterMods = “ATR Filter off!”;
return(1);
}
}
//*******************************************************************************************************
bool Filter()
{
ATRProfitTrigger=false;
if ((ReadATR()&&News()&&CCI()&&Momentum()&&RSI()&&MA()&&Envelopes())
||(IfOrderDoesNotExist(1))||(IfOrderDoesNotExist(0)))
{
Filter = “Not Filtering!”;
if (!ReadATR()&&((IfOrderDoesNotExist(1))||(IfOrderDoesNotExist(0))))
{
Filter = “Filter Overide!”;
ATRProfitTrigger=true;
}
if ((!News()||!CCI()||!Momentum()||!RSI()||!MA()||!Envelopes())&&(IfOrderDoesNotExist(1)||IfOrderDoesNotExist(0)))
{
Filter = “Filter Overide!”;
ATRProfitTrigger=true;
}
return(1);
}
else
{
Filter = “Filtering!”;
if (DeletePOATR)
{
DeletePendingOrder(2);
DeletePendingOrder(3);
}
if (DeleteOrderATR)
{
CloseOrder(1);
CloseOrder(0);
}
return(0);
}
}
//*******************************************************************************************************
void SendOrder()
{
if(!ReverseOrder)
{
if(IfOrderDoesNotExist(2)&&IfOrderDoesNotExist(1)&&DeletePOMode)DeletePendingOrder(2);
if(IfOrderDoesNotExist(3)&&IfOrderDoesNotExist(0)&&DeletePOMode)DeletePendingOrder(3);
if(!IfOrderDoesNotExist(2)&&!IfOrderDoesNotExist(1)&&Filter())PendingOrder(2);
if(!IfOrderDoesNotExist(3)&&!IfOrderDoesNotExist(0)&&Filter())PendingOrder(3);
}
else
{
if(IfOrderDoesNotExist(2)&&IfOrderDoesNotExist(1)&&DeletePOMode&&OrderCounter<OpenOrderTreshold)DeletePendingOrder(2);
if(IfOrderDoesNotExist(3)&&IfOrderDoesNotExist(0)&&DeletePOMode&&OrderCounter<OpenOrderTreshold)DeletePendingOrder(3);
if(!IfOrderDoesNotExist(2)&&!IfOrderDoesNotExist(1)&&Filter()&&OrderCounter<OpenOrderTreshold)PendingOrder(2);
if(!IfOrderDoesNotExist(3)&&!IfOrderDoesNotExist(0)&&Filter()&&OrderCounter<OpenOrderTreshold)PendingOrder(3);
if(IfOrderDoesNotExist(0)&&OrderCounter<OpenOrderTreshold)
{
BuyBasket=true;
SellBasket=false;
}
if(IfOrderDoesNotExist(1)&&OrderCounter<OpenOrderTreshold)
{
SellBasket=true;
BuyBasket=false;
}
if(!IfOrderDoesNotExist(2)&&BuyBasket&&!SellBasket)
{
if(ReversalContBasket)
if(OrderCounter>=OpenOrderTreshold)PendingOrder(2);
if(OrderCounter>=OpenOrderTreshold)MarketOrder(1);
}
if(!IfOrderDoesNotExist(3)&&!BuyBasket&&SellBasket)
{
if(ReversalContBasket)
if(OrderCounter>=OpenOrderTreshold)PendingOrder(3);
if(OrderCounter>=OpenOrderTreshold)MarketOrder(0);
}
}
}
//*******************************************************************************************************
void MarketOrder(int Mode)
{
double price;
color ColorSet;
double SL;
double TP;
double MarketLot=(LotSize()/ReverseOrderLotDiv);
int SlippageOrder=Slippage*PipValue;
if(Mode==1)
{
price = NormalizeDouble(Bid, NDigits);
SL = price + SingleOrderSL*PipValue*Point;
TP = price – SingleOrderTP*PipValue*Point;
ColorSet=Red;
}
if(Mode==0)
{
price = NormalizeDouble(Ask, NDigits);
SL = price – SingleOrderSL*PipValue*Point;
TP = price + SingleOrderTP*PipValue*Point;
ColorSet=Blue;
}
if (SingleOrderSL == 0) SL = 0;
if (SingleOrderTP == 0) TP = 0;
while (!IsTradeAllowed()) Sleep(100);
int ticket = OrderSend(Symbol(), Mode, MarketLot, price, SlippageOrder, SL, TP, EAName, Magic, 0, ColorSet);
Print(“MarketLot: “+MarketLot);
if (ticket == -1)
{
Print(“OrderSend() error – “, ErrorDescription(GetLastError()));
}
}
//*******************************************************************************************************
bool IfOrderDoesNotExist(int Type)
{
for (int i=OrdersTotal()-1; i >= 0; i–)
if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
{
if (OrderType() == Type && OrderSymbol() == Symbol() && OrderMagicNumber() == Magic)
{
return(1);
}
}
else
{
Print(“OrderSelect() error – “, ErrorDescription(GetLastError()));
}
}
//*******************************************************************************************************
void PendingOrder(int Mode)
{
int expire = TimeCurrent() + 60 * 0;
double price;
color ColorSet;
double PriceType;
int CallLastOrder;
double SL;
double TP;
int SlippageOrder=Slippage*PipValue;
if(Mode==2)
{
ColorSet=Blue;
PriceType=Ask;
CallLastOrder=0;
}
if(Mode==3)
{
ColorSet=Red;
PriceType=Bid;
CallLastOrder=1;
}
if(Mode==3)
{
if(!ADVOffsetMode)price = NormalizeDouble(PriceType, NDigits) – Step()*PipValue*Point;
if(ADVOffsetMode&&!IfOrderDoesNotExist(CallLastOrder))price = NormalizeDouble(PriceType, NDigits) – Step()*PipValue*Point;
if(ADVOffsetMode&&IfOrderDoesNotExist(CallLastOrder))price = NormalizeDouble(GetLastOrderPrice(CallLastOrder), NDigits) – Step()*PipValue*Point;
SL = price + SingleOrderSL*PipValue*Point;
TP = price – SingleOrderTP*PipValue*Point;
}
if(Mode==2)
{
if(!ADVOffsetMode)price = NormalizeDouble(PriceType, NDigits) + Step()*PipValue*Point;
if(ADVOffsetMode&&!IfOrderDoesNotExist(CallLastOrder))price = NormalizeDouble(Ask, NDigits) + Step()*PipValue*Point;
if(ADVOffsetMode&&IfOrderDoesNotExist(CallLastOrder))price = NormalizeDouble(GetLastOrderPrice(CallLastOrder), NDigits) + Step()*PipValue*Point;
SL = price – SingleOrderSL*PipValue*Point;
TP = price + SingleOrderTP*PipValue*Point;
}
if (SingleOrderSL == 0) SL = 0;
if (SingleOrderTP == 0) TP = 0;
if (0 == 0) expire = 0;
while (!IsTradeAllowed()) Sleep(100);
int ticket = OrderSend(Symbol(), Mode, LotSize(), price, SlippageOrder, SL, TP, EAName, Magic, expire, ColorSet);
if (ticket == -1)
{
Print(“OrderSend() error – “, ErrorDescription(GetLastError()));
}
}
//*******************************************************************************************************
void CheckLastOrderType33()
{
int orderType = -1;
datetime lastCloseTime = 0;
int cnt = OrdersHistoryTotal();
for (int i=0; i < cnt; i++)
{
if (!OrderSelect(i, SELECT_BY_POS, MODE_HISTORY)) continue;
if (OrderSymbol() == Symbol() && OrderMagicNumber() == Magic && lastCloseTime < OrderCloseTime())
{
lastCloseTime = OrderCloseTime();
orderType = OrderType();
}
}
if (orderType == OP_SELL || FirstTime33)
{
FirstTime33 = false;
DeletePendingOrder(3);
}
}
//*******************************************************************************************************
void DeletePendingOrder(int Mode)
{
while (!IsTradeAllowed()) Sleep(100);
for (int i=OrdersTotal()-1; i >= 0; i–)
if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
{
if (OrderType() == Mode && OrderSymbol() == Symbol() && OrderMagicNumber() == Magic)
{
bool ret = OrderDelete(OrderTicket(), CLR_NONE);
if (ret == false)
{
Print(“OrderDelete() error – “, ErrorDescription(GetLastError()));
}
}
}
}
//*******************************************************************************************************
void CheckLastOrderType35()
{
int orderType = -1;
datetime lastCloseTime = 0;
int cnt = OrdersHistoryTotal();
for (int i=0; i < cnt; i++)
{
if (!OrderSelect(i, SELECT_BY_POS, MODE_HISTORY)) continue;
if (OrderSymbol() == Symbol() && OrderMagicNumber() == Magic && lastCloseTime < OrderCloseTime())
{
lastCloseTime = OrderCloseTime();
orderType = OrderType();
}
}
if (orderType == OP_BUY || FirstTime35)
{
FirstTime35 = false;
DeletePendingOrder(2);
}
}
//*******************************************************************************************************
void AtCertainTime6()
{
int datetime800 = TimeLocal();
int hour0 = TimeHour(datetime800);
int minute0 = TimeMinute(datetime800);
int Stop_Hour = StopHour + GMTOffset;
if ((DayOfWeek() != Today6 && hour0 == Stop_Hour && minute0 == StopMinute)&&(TimedStop == true))
{
Today6 = DayOfWeek();
CloseOrder(1);
CloseOrder(1);
}
}
//*******************************************************************************************************
void CloseOrder(int Mode)
{
int orderstotal = OrdersTotal();
int orders = 0;
int ordticket[30][2];
color ColorSet;
int SlippageOrder=Slippage*PipValue;
if(Mode==0)DeletePendingOrder(2);
if(Mode==1)DeletePendingOrder(3);
if(Mode==0)ColorSet=Blue;
if(Mode==1)ColorSet=Red;
while (!IsTradeAllowed()) Sleep(100);
for (int i = 0; i < orderstotal; i++)
{
OrderSelect(i, SELECT_BY_POS, MODE_TRADES);
if (OrderType() != Mode || OrderSymbol() != Symbol() || OrderMagicNumber() != Magic)
{
continue;
}
ordticket[orders][0] = OrderOpenTime();
ordticket[orders][1] = OrderTicket();
orders++;
}
if (orders > 1)
{
ArrayResize(ordticket,orders);
ArraySort(ordticket);
}
for (i = 0; i < orders; i++)
{
if (OrderSelect(ordticket[1], SELECT_BY_TICKET) == true)
{
bool ret = OrderClose(OrderTicket(), OrderLots(), OrderClosePrice(), SlippageOrder, ColorSet);
if (ret == false)
Print(“OrderClose() error – “, ErrorDescription(GetLastError()));
}
}
}
//*******************************************************************************************************
void OnceAnHour1()
{
int datetime800 = TimeLocal();
int hour0 = TimeHour(datetime800);
int minute0 = TimeMinute(datetime800);
if (hour0 != Hour1 && minute0 == Minute1)
{
Hour1 = hour0;
RandomMagicNumber();
}
}
//*******************************************************************************************************
void RandomMagicNumber()
{
if((!IfOrderDoesNotExist(1))&&(!IfOrderDoesNotExist(0))&&(!IfOrderDoesNotExist(2))&&(!IfOrderDoesNotExist(3))&&(UseRandomMagic==true)&&(!IsTesting()))
{
MathSrand(TimeCurrent());
double random = RandomMagicLower + (RandomMagicUpper – RandomMagicLower) * MathRand()/32768.0;
Magic = MathRound(random);
MagicChange = TimeToStr(TimeCurrent());
Print(“Indo Run Magic Number changed: ” + Magic);
WriteMagic();
}
if (UseRandomMagic == false)
{
RMStatus = “Inactive!”;
}
else
{
RMStatus = “Active!”;
}
}
//*******************************************************************************************************
void ReadMagic()
{
string str;
int handle=FileOpen(“IndoRun_Magic.dat”, FILE_CSV | FILE_READ); //or .txt
if((handle>0)&&(UseRandomMagic == true)&&(!IsTesting()))
{
str = FileReadString(handle);
Magic = StrToInteger(str);
FileClose(handle);
Print(“Indo Run Magic Number loaded: ” + Magic);
}
}
//*******************************************************************************************************
void WriteMagic()
{
int handle=FileOpen(“IndoRun_Magic.dat”, FILE_CSV | FILE_WRITE);
if((handle>0)&&(!IsTesting()))
{
FileWrite(handle, Magic);
FileClose(handle);
Print(“Indo Run Magic Number writen to file: ” + Magic);
}
}
//*******************************************************************************************************
double LastOrderLotSize(int Type)
{
for (int i=OrdersTotal()-1; i >= 0; i–)
if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
{
if (OrderType() == Type && OrderSymbol() == Symbol() && OrderMagicNumber() == Magic)
{
return(OrderLots());
}
}
else
{
Print(“OrderSelect() error – “, ErrorDescription(GetLastError()));
}
}
//*******************************************************************************************************
double LotSize()
{
if(KLotSize)
{
Lots=(MathFloor(AccountBalance()/10000))*Lot;
if(Lots<Lot)Lots=Lot;
AutoLot= “10K Lotsize active!”;
}
if ((AutoLotSize)&&(Risk>0)&&(!KLotSize))
{
Lots=(AccountBalance()*Risk*MinLots)/1000;
AutoLot = “Auto Lotsize!”;
if(DoubleLots)
{
Double_Lot = “Sleeping!”;
if(AsianSession)
{
Lots = (AccountBalance()*Risk*MinLots*2)/1000;
Double_Lot = “Active!”;
}
if((!AsianSession&&IfOrderDoesNotExist(0)&&LastOrderLotSize(0)>Lots)
||(!AsianSession&&IfOrderDoesNotExist(1)&&LastOrderLotSize(1)>Lots))
{
Lots = (AccountBalance()*Risk*MinLots*2)/1000;
Double_Lot = “Override!”;
}
}
}
else
{
if(!KLotSize)AutoLot = “Manual Lotsize!”;
if(DoubleLots)
{
if(AsianSession)
{
if(KLotSize)
{
Double_Lot = “Active!”;
Lots=Lots*2;
}
else
{
Double_Lot = “Active!”;
Lots = Lot * 2;
}
}
else
{
if((IfOrderDoesNotExist(0)&&LastOrderLotSize(0)>Lots)
||(IfOrderDoesNotExist(1)&&LastOrderLotSize(1)>Lots))
{
if(KLotSize)
{
Lots=Lots*2;
Double_Lot = “Override!”;
}
else
{
Lots = Lot * 2;
Double_Lot = “Override!”;
}
}
else
{
if(KLotSize)
{
Double_Lot = “Sleeping!”;
Lots=Lots;
}
else
{
Double_Lot = “Sleeping!”;
Lots = Lot;
}
}
}
}
if(!DoubleLots)
{
if(KLotSize)
{
Double_Lot = “Inactive!”;
Lots=Lots;
}
else
{
Double_Lot = “Inactive!”;
Lots = Lot;
}
}
}
if (Lots<=MinLots)
{
Lots=MinLots;
}
BuyLots=Lots;
SellLots=Lots;
if (Martingale==true)
{
int OrderCount=0;
AutoLot= “Martingale!”;
if(IfOrderDoesNotExist(0))
{
if(OrderCounter<=0)OrderCount=1;
if(OrderCounter>=1)OrderCount=OrderCounter+1;
BuyLots=BuyLots*LotFactor*OrderCount;
if (BuyLots>=MartingaleMaxLot)
{
BuyLots=MartingaleMaxLot;
}
Lots=BuyLots;
}
if(IfOrderDoesNotExist(1))
{
if(OrderCounter<=0)OrderCount=1;
if(OrderCounter>=1)OrderCount=OrderCounter+1;
SellLots=SellLots*LotFactor*OrderCount;
if (SellLots>=MartingaleMaxLot)
{
SellLots=MartingaleMaxLot;
}
Lots=SellLots;
}
}
if (Lots<=MinLots)
{
Lots=MinLots;
}
return(Lots);
}
//*******************************************************************************************************
double Profit()
{
double TotalLots[1000];
TotalTradeLots = 0;
ProfitAllOrders = MathFloor(ProfitAllOrder*10*Lots);
TrailingStops= MathFloor(TrailingStop*10*Lots);
double n[1000];
int s = 0;
int m = 1;
for (int i=OrdersTotal()-1; i >= 0; i–)
if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
{
if (OrderType() == (OP_BUY) && OrderSymbol() == Symbol() && OrderMagicNumber() == Magic)
{
TotalLots = OrderLots();
TotalTradeLots=TotalTradeLots+TotalLots;
if (ADVProfitMode == true)
{
m = m+i;
if (FixedProfitAO==false)
{
ProfitAllOrders=ProfitAllOrder*10*TotalTradeLots/m;
TrailingStops=TrailingStop*10*TotalTradeLots/m;
}
}
else
{
n = 1;
s = s + n;
if (FixedProfitAO==false)
{
ProfitAllOrders=ProfitAllOrder*10*TotalTradeLots/s;
TrailingStops=TrailingStop*10*TotalTradeLots/s;
}
}
}
}
double p[1000];
int r = 0;
int o = 1;
for (int k=OrdersTotal()-1; k >= 0; k–)
if (OrderSelect(k, SELECT_BY_POS, MODE_TRADES))
{
if (OrderType() == (OP_SELL) && OrderSymbol() == Symbol() && OrderMagicNumber() == Magic)
{
TotalLots[k] = OrderLots();
TotalTradeLots=TotalTradeLots+TotalLots[k];
if (ADVProfitMode == true)
{
o = o+1;
if (FixedProfitAO==false)
{
ProfitAllOrders = ProfitAllOrder*10*TotalTradeLots/o;
TrailingStops = TrailingStop*10*TotalTradeLots/o;
}
}
else
{
p[k] = 1;
r = r + p[k];
if (FixedProfitAO==false)
{
ProfitAllOrders = ProfitAllOrder*10*TotalTradeLots/r;
TrailingStops = TrailingStop*10*TotalTradeLots/r;
}
}
}
}
if (FixedProfitAO==true)ProfitAllOrders = ProfitAllOrder;
if (ATRProfitMode&&ATRProfitTrigger&&!ADVATRProfit)ProfitAllOrders=ATRProfit;
if (ATRProfitMode&&ATRProfitTrigger&&ADVATRProfit)ProfitAllOrders=ProfitAllOrders/ADVATRProfitx;
if (Trailing)
{
if (Breakeven)
{
if (OrderCounter>OrderTreshold)ProfitAllOrders=BE;
}
if (OrderTrailing)
{
if (OrderCounter>OrderTreshold+1)ProfitAllOrders=ProfitAllOrders-((OrderCounter-(OrderTreshold+1))*TrailingStops);
}
}
return(ProfitAllOrders);
}
//*******************************************************************************************************
bool News()
{
if (AvoidNews && !IsTesting() && !IsOptimization())
{
Check_News_Calendar();
for (int i=0; i<=NewsTotal; i++)
{
if (NewsRatings == 3)
{
datetime BeforeNews = NewsTimes – MinsUntilNextHighNews*60;
datetime AfterNews = NewsTimes + MinsSincePrevHighNews*60;
}
else if (NewsRatings == 2)
{
BeforeNews = NewsTimes – MinsUntilNextMediumNews*60;
AfterNews = NewsTimes + MinsSincePrevMediumNews*60;
}
else if (NewsRatings == 1) {
BeforeNews = NewsTimes – MinsUntilNextLowNews*60;
AfterNews = NewsTimes + MinsSincePrevLowNews*60;
}
if ((TimeCurrent() >= BeforeNews && TimeCurrent() <= AfterNews))
{
if (High_Impact && NewsRatings == 3)
{
NewsF = “Avoiding High Impact News!”;
return(0);
}
if (Medium_Impact && NewsRatings == 2)
{
NewsF = “Avoiding Medium Impact News!”;
return(0);
}
if (Low_Impact && NewsRatings == 1)
{
NewsF = “Avoiding Low Impact News!”;
return(0);
}
}
}
NewsF = “No News to filter!”;
return(1);
}
if (!AvoidNews)
{
NewsF = “News Filter off!”;
return(1);
}
return(1);
}
//*******************************************************************************************************
bool CCI()
{
if (CCIFilterOn == true)
{
double CCICurrent = iCCI(Symbol(),0,CCIPeriod1,PRICE_TYPICAL,CCIShift1);
double CCIPrevious = iCCI(Symbol(),0,CCIPeriod2,PRICE_TYPICAL,CCIShift2);
CCIStatus = “CCI Current/Shift: “+DoubleToStr(CCICurrent, 2)+” / “+DoubleToStr(CCIPrevious, 2);
if (CCICurrent>CCICurrentUp||CCICurrentCCIPreviousUp||CCIPrevious<CCIPreviousDown)
{
return(0);
}
else
{
return(1);
}
}
else
{
CCIStatus = “CCI Filter off!”;
return(1);
}
}
//*******************************************************************************************************
bool Momentum()
{
if (MomentumFilterOn == true)
{
double MomentumCurrent = iMomentum(Symbol(),0,MomentumPeriod1,PRICE_TYPICAL,MomentumShift1);
double MomentumPrevious = iMomentum(Symbol(),0,MomentumPeriod2,PRICE_TYPICAL,MomentumShift2);
MomentumStatus = “Momentum Current/Shift: “+DoubleToStr(MomentumCurrent, 2)+” / “+DoubleToStr(MomentumPrevious, 2);
if (MomentumCurrent>MomentumCurrentUp||MomentumCurrentMomentumPreviousUp||MomentumPrevious<MomentumPreviousDown)
{
return(0);
}
else
{
return(1);
}
}
else
{
MomentumStatus = “Momentum Filter off!”;
return(1);
}
}
//*******************************************************************************************************
bool RSI()
{
if (RSIFilterOn == true)
{
double RSICurrent = iRSI(Symbol(),0,RSIPeriod1,PRICE_TYPICAL,RSIShift1);
double RSIPrevious = iRSI(Symbol(),0,RSIPeriod2,PRICE_TYPICAL,RSIShift2);
RSIStatus = “RSI Current/Shift: “+DoubleToStr(RSICurrent, 2)+” / “+DoubleToStr(RSIPrevious, 2);
if (RSICurrent>RSICurrentUp||RSICurrentRSIPreviousUp||RSIPrevious<RSIPreviousDown)
{
return(0);
}
else
{
return(1);
}
}
else
{
RSIStatus = “RSI Filter off!”;
return(1);
}
}
//*******************************************************************************************************
bool MA()
{
if (MAFilterOn == true)
{
double MACurrent = iMA(Symbol(),0,MAPeriod1,MAIShift1,MAMethod,PRICE_TYPICAL,MAShift1);
double MAPrevious = iMA(Symbol(),0,MAPeriod2,MAIShift2,MAMethod,PRICE_TYPICAL,MAShift2);
MAStatus = “MA Current/Shift: “+DoubleToStr(MACurrent, 5)+” / “+DoubleToStr(MAPrevious, 5);
if (MACurrent>(MACurrentUp+MAPrevious)||MACurrent<(MAPrevious-MACurrentDown)
||MAPrevious>(MAPreviousUp+MACurrent)||MAPrevious<(MACurrent-MAPreviousDown))
//ToDo: change MA Filter to Crossover Fast/Slow MA
{
return(0);
}
else
{
return(1);
}
}
else
{
MAStatus = “MA Filter off!”;
return(1);
}
}
//*******************************************************************************************************
bool Envelopes()
{
if (EnvelopesFilterOn == true)
{
double EnvelopesUpper = iEnvelopes(Symbol(),EnvelopesTimeFrame,EnvelopesMAPeriod1,EnvelopesMAMethod,EnvelopesMAShift1,EnvelopesAppliedPrice,EnvelopesDeviation,1,EnvelopesShift1);
double EnvelopesLower = iEnvelopes(Symbol(),EnvelopesTimeFrame,EnvelopesMAPeriod2,EnvelopesMAMethod,EnvelopesMAShift2,EnvelopesAppliedPrice,EnvelopesDeviation,2,EnvelopesShift2);
EnvelopeStatus = “Envelopes Current/Shift: “+DoubleToStr(EnvelopesUpper, 5)+” / “+DoubleToStr(EnvelopesLower, 5);
RefreshRates();
if (MarketInfo(Symbol(),MODE_ASK)>EnvelopesUpper||MarketInfo(Symbol(),MODE_BID)<EnvelopesLower)
{
return(0);
}
else
{
return(1);
}
}
else
{
EnvelopeStatus = “Envelopes Filter off!”;
return(1);
}
}
//*******************************************************************************************************
double GetLastOrderPrice(int Type)
{
for (int i =OrdersTotal() – 1 ; i >= 0; i–)
{
OrderSelect(i, SELECT_BY_POS, MODE_TRADES);
if (OrderMagicNumber() == Magic && OrderSymbol() == Symbol() && OrderType() == Type)
{
return (OrderOpenPrice());
}
}
return (0);
}
//*******************************************************************************************************
double Step()
{
if(ATRStepOn&&!ATRPipsToStep)
{
if(ATRPips
请帮我加上此EA自动挂单后的声音报警提醒功能(声音可以教我自己可改)
IndoRun1.5.rar
18.29 KB,下载次数：0,下载积分：活跃 -2[记录]
暂无描述
请登录之后再进行评论
登录
