MT4 - Expert Advisors (EA) code for traders

0

0FXTrader0

I would like to start this thread where traders can paste there code (mt4 EA's only) no links or attachments. Below is scalping algo I like to run on a discretionary basis long only or short only.


//+------------------------------------------------------------------+
//| GONNA SCALPING |
//| https://5d3071208c5e2.site123.me/ |
//+------------------------------------------------------------------+
#property copyright "AHARON TZADIK"
#property link "https://5d3071208c5e2.site123.me/"
#property version "1.00"
#property strict

//--------------------------------------------------------------- 2 --

//--------------------------------------------------------------- 3 --
extern bool Exit=FALSE;//Enable Exit strategy
bool USEMOVETOBREAKEVEN=true;//Enable "no loss"
double WHENTOMOVETOBE=30; //When to move break even
double PIPSTOMOVESL=30; //How much pips to move sl
extern double Lots=0.01; //Lots size
extern double IncreaseFactor=0.001; //IncreaseFactor
extern double TrailingStop=40; //TrailingStop
extern double Stop_Loss=200; //Stop Loss
extern int MagicNumber=1234; //MagicNumber
input double Take_Profit=200; //TakeProfit
extern int FastMA=1; //FastMA
extern int SlowMA=5; //SlowMA
extern double Mom_Sell=0.3; //Momentum_Sell
extern double Mom_Buy=0.3; //Momentum_Buy
input bool UseEquityStop = true; //Use Equity Stop
input double TotalEquityRisk = 1.0; //Total Equity Risk
input int Max_Trades=5;

double AccountEquityHighAmt,PrevEquity;

string EAName="R_O_B_O_T "; // EA name , to be displayed on the screen
#define DECISION_BUY 1
#define DECISION_SELL 0
#define DECISION_UNKNOWN -1
int err;
double BidPrev = 0;
double AskPrev = 0;
double CHOCurrent;
double CHOPrevious;
double StopLossIndex = 0;
double TakeProfitIndex = 0;
int ToSell=0;
int ToBuy =0;
int FoundOpenedOrder = false;
int Decision;
int PrevDecision;
//int cnt;
datetime PauseTo;
static datetime Old_Time=0;
double CHOCurrentExit,CHOPreviousExit,RSICurrentExit,RSIPreviousExit;
// Variables to assess the quality of modeling
double pipe;
// Variables for the storage information (data) about the market
double ModeLow;
double ModeHigh;
double ModeTime;
double ModeBid;
double ModeAsk;
double ModePoint;
double ModeDigits;
double ModeSpread;
double ModeStopLevel;
double ModeLotSize;
double ModeTickValue;
double ModeTickSize;
double ModeSwapLong;
double ModeSwapShort;
double ModeStarting;
double ModeExpiration;
double ModeTradeAllowed;
double ModeMinLot;
double ModeLotStep;


// ------ Stochastic Indicator ---
double STOCHCurrent;
double STOCHPrevious;
double STOCHSigCurrent;
double STOCHSigPrevious;
int STOCH_Status;

//------- CCI Indicator -------
double CCICurrent;
double CCIPrevious;
int CCI_Status;
//------- RSI Indicator -------
double RSICurrent;
double RSIPrevious;
int RSI_Status;
int MA_Status;
double ATRCurrent;
double ATRPrevious;
int ATR_Status;
int ROC_Status;
double OSMACurrent;
int CandleStatus;
int OSMA_Status;
int MACDStatus;
int FIBOStatus;
int SR_Status;
//int MACD_Status
double MomentCurrent;
double MomentPrevious;
//------------ PivotPoint --------------
int total=0;
double
Lot,Dmax,Dmin,// Amount of lots in a selected order
Lts, // Amount of lots in an opened order
Min_Lot, // Minimal amount of lots
Step, // Step of lot size change
Free, // Current free margin
One_Lot, // Price of one lot
Price, // Price of a selected order,
pips,
MA_1,MA_2,MACD_SIGNAL;
int Type,freeze_level,Spread;
//--- price levels for orders and positions
double priceopen,stoploss,takeprofit;
//--- ticket of the current order
int orderticket;

//--------------------------------------------------------------- 3 --
int
Period_MA_2, Period_MA_3, // Calculation periods of MA for other timefr.
Period_MA_02, Period_MA_03, // Calculation periods of supp. MAs
K2,K3,T,L;
//---

//+------------------------------------------------------------------+
//| Expert initialization function |
//+------------------------------------------------------------------+
int OnInit()
{
MA_Status = DECISION_UNKNOWN;
ROC_Status = DECISION_UNKNOWN;
CCI_Status = DECISION_UNKNOWN;
RSI_Status = DECISION_UNKNOWN;
STOCH_Status = DECISION_UNKNOWN;

Decision = DECISION_UNKNOWN;
PrevDecision = DECISION_UNKNOWN;
CandleStatus = DECISION_UNKNOWN;
SR_Status = DECISION_UNKNOWN;
OSMA_Status = DECISION_UNKNOWN;
MACDStatus = DECISION_UNKNOWN;
FIBOStatus = DECISION_UNKNOWN;
//--------------------------------------------------------------- 5 --
//--------------------------------------------------------------- 5 --
switch(Period()) // Calculating coefficient for..
{
// .. different timeframes
case 1:
L=PERIOD_M5;
T=PERIOD_M15;
break;// Timeframe M1
case 5:
L=PERIOD_M1;
T=PERIOD_M15;
break;// Timeframe M5
case 15:
L=PERIOD_M5;
T=PERIOD_M30;
break;// Timeframe M15
case 30:
L=PERIOD_M15;
T=PERIOD_H1;
break;// Timeframe M30
case 60:
L=PERIOD_M30;
T=PERIOD_H4;
break;// Timeframe H1
case 240:
L=PERIOD_H1;
T=PERIOD_D1;
break;// Timeframe H4
case 1440:
L=PERIOD_H4;
T=PERIOD_W1;
break;// Timeframe D1
case 10080:
L=PERIOD_D1;
T=PERIOD_MN1;
break;// Timeframe W1
case 43200:
L=PERIOD_W1;
T=PERIOD_D1;
break;// Timeframe MN
}

double ticksize=MarketInfo(Symbol(),MODE_TICKSIZE);
if(ticksize==0.00001 || ticksize==0.001)
pips=ticksize*10;
else
pips=ticksize;
return(INIT_SUCCEEDED);
//--- distance from the activation price, within which it is not allowed to modify orders and positions
freeze_level=(int)SymbolInfoInteger(_Symbol,SYMBOL_TRADE_FREEZE_LEVEL);
if(freeze_level!=0)
{
PrintFormat("SYMBOL_TRADE_FREEZE_LEVEL=%d: order or position modification is not allowed,"+
" if there are %d points to the activation price",freeze_level,freeze_level);
}

//---
return(INIT_SUCCEEDED);
}
//+------------------------------------------------------------------+
//| Expert deinitialization function |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
void OnTick(void)
{
double CurrentPairProfit=CalculateProfit();
Comment(EAName); // Show EA Name on screen
// Check for New Bar (Compatible with both MQL4 and MQL5)
static datetime dtBarCurrent=WRONG_VALUE;
datetime dtBarPrevious=dtBarCurrent;
dtBarCurrent=(datetime) SeriesInfoInteger(_Symbol,_Period,SERIES_LASTBAR_DATE);
bool NewBarFlag=(dtBarCurrent!=dtBarPrevious);
if(NewBarFlag)
{
if(UseEquityStop)
{
if(CurrentPairProfit<0.0 && MathAbs(CurrentPairProfit)>TotalEquityRisk/100.0*AccountEquityHigh())
{
CloseThisSymbolAll();
Print("Closed All due to Stop Out");

}
}

if(Exit)
{
stop();
}
if(USEMOVETOBREAKEVEN)
{MOVETOBREAKEVEN();}
Trail1();
int ticket=0;
// initial data checks
// it is important to make sure that the expert works with a normal
// chart and the user did not make any mistakes setting external
// variables (Lots, StopLoss, TakeProfit,
// TrailingStop) in our case, we check TakeProfit
// on a chart of less than 100 bars
//---
if(Bars<100)
{
Print("bars less than 100");
return;
}
if(Take_Profit<10)
{
Print("TakeProfit less than 10");
return;
}
//--- to simplify the coding and speed up access data are put into internal variables
HideTestIndicators(true);
//+------------------------------------------------------------------+
double MA_1_t=iMA(NULL,L,FastMA,0,MODE_LWMA,PRICE_TYPICAL,0); // МА_1
double MA_2_t=iMA(NULL,L,SlowMA,0,MODE_LWMA,PRICE_TYPICAL,0); // МА_2
//----------------------------------------------------------------------------
double MomLevel=MathAbs(100-iMomentum(NULL,T,14,PRICE_CLOSE,1));
double MomLevel1=MathAbs(100 - iMomentum(NULL,T,14,PRICE_CLOSE,2));
double MomLevel2=MathAbs(100 - iMomentum(NULL,T,14,PRICE_CLOSE,3));
//----------------------------------------------------------------------------
HideTestIndicators(false);
//--------------------------------------------------------------------------------------------------
// if(getOpenOrders()==0)
if(CountTrades()<Max_Trades)
{
//--- no opened orders identified
if(AccountFreeMargin()<(1000*Lots))
{
Print("We have no money. Free Margin = ",AccountFreeMargin());
return;
}

//--- check for long position (BUY) possibility
//+------------------------------------------------------------------+
//| BUY BUY BUY |
//+------------------------------------------------------------------+
if(Trade1()==1)
// if(MA_1_t>MA_2_t)
// if(MomLevel<Mom_Buy || MomLevel1<Mom_Buy || MomLevel2<Mom_Buy)
{
if((CheckVolumeValue(LotsOptimized(Lots)))==TRUE)
if((CheckMoneyForTrade(Symbol(),LotsOptimized(Lots),OP_BUY))==TRUE)
if((CheckStopLoss_Takeprofit(OP_BUY,NDTP(Bid-Stop_Loss*pips),NDTP(Bid+Take_Profit*pips)))==TRUE)
ticket=OrderSend(Symbol(),OP_BUY,LotsOptimized(Lots),ND(Ask),3,NDTP(Bid-Stop_Loss*pips),NDTP(Bid+Take_Profit*pips),"Long 1",MagicNumber,0,PaleGreen);
if(ticket>0)
{
if(OrderSelect(ticket,SELECT_BY_TICKET,MODE_TRADES))
Print("BUY order opened : ",OrderOpenPrice());
Alert("we just got a buy signal on the ",_Period,"M",_Symbol);
SendNotification("we just got a buy signal on the1 "+(string)_Period+"M"+_Symbol);
SendMail("Order sent successfully","we just got a buy signal on the1 "+(string)_Period+"M"+_Symbol);
}
else
Print("Error opening BUY order : ",GetLastError());
return;
}
//--- check for short position (SELL) possibility
//+------------------------------------------------------------------+
//| SELL SELL SELL |
//+------------------------------------------------------------------+
if(Trade1()==2)
// if(MA_1_t<MA_2_t)
// if(MomLevel<Mom_Sell || MomLevel1<Mom_Sell || MomLevel2<Mom_Sell)
{
if((CheckVolumeValue(LotsOptimized(Lots)))==TRUE)
if((CheckMoneyForTrade(Symbol(),LotsOptimized(Lots),OP_SELL))==TRUE)
if((CheckStopLoss_Takeprofit(OP_SELL,NDTP(Ask+Stop_Loss*pips),NDTP(Ask-Take_Profit*pips)))==TRUE)
ticket=OrderSend(Symbol(),OP_SELL,LotsOptimized(Lots),ND(Bid),3,NDTP(Ask+Stop_Loss*pips),NDTP(Ask-Take_Profit*pips),"Short 1",MagicNumber,0,Red);
if(ticket>0)
{
if(OrderSelect(ticket,SELECT_BY_TICKET,MODE_TRADES))
Print("SELL order opened : ",OrderOpenPrice());
Alert("we just got a sell signal on the ",_Period,"M",_Symbol);
SendMail("Order sent successfully","we just got a sell signal on the "+(string)_Period+"M"+_Symbol);
}
else
Print("Error opening SELL order : ",GetLastError());
}
//--- exit from the "no opened orders" block
return;
}
}
}
//+------------------------------------------------------------------+
//| stop |
//+------------------------------------------------------------------+
//-----------------------------------------------------------------------------+
int stop()
{
total=0;
HideTestIndicators(true);
double MA_1_t=iMA(NULL,L,FastMA,0,MODE_LWMA,PRICE_TYPICAL,0); // МА_1
double MA_2_t=iMA(NULL,L,SlowMA,0,MODE_LWMA,PRICE_TYPICAL,0); // МА_2
//+------------------------------------------------------------------+
double middleBB=iBands(Symbol(),0,20, 2,0,0,MODE_MAIN,1);//middle
double lowerBB=iBands(Symbol(),0,20, 2,0,0,MODE_LOWER,1);//lower
double upperBB=iBands(Symbol(),0,20, 2,0,0,MODE_UPPER,1);//upper
//+------------------------------------------------------------------+
double MacdMAIN=iMACD(NULL,0,12,26,9,PRICE_CLOSE,MODE_MAIN,1);
double MacdSIGNAL=iMACD(NULL,0,12,26,9,PRICE_CLOSE,MODE_SIGNAL,1);
double MacdMAIN0=iMACD(NULL,0,12,26,9,PRICE_CLOSE,MODE_MAIN,1);
double MacdSIGNAL0=iMACD(NULL,0,12,26,9,PRICE_CLOSE,MODE_SIGNAL,1);
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
// DALYN GUPPY MMA
//----------------------------------------------------------------------------
double MA_3=iMA(NULL,L,3,0,MODE_EMA,PRICE_TYPICAL,0); // МА_3 DALYN GUPPY MMA
double MA_5=iMA(NULL,L,5,0,MODE_EMA,PRICE_TYPICAL,0); // МА_5 DALYN GUPPY MMA
double MA_8=iMA(NULL,L,8,0,MODE_EMA,PRICE_TYPICAL,0); // МА_8 DALYN GUPPY MMA
double MA_10=iMA(NULL,L,10,0,MODE_EMA,PRICE_TYPICAL,0); // МА_10 DALYN GUPPY MMA
double MA_12=iMA(NULL,L,12,0,MODE_EMA,PRICE_TYPICAL,0); // МА_12 DALYN GUPPY MMA
double MA_15=iMA(NULL,L,15,0,MODE_EMA,PRICE_TYPICAL,0); // МА_15 DALYN GUPPY MMA
double MA_30=iMA(NULL,L,30,0,MODE_EMA,PRICE_TYPICAL,0); // МА_30 DALYN GUPPY MMA
double MA_35=iMA(NULL,L,35,0,MODE_EMA,PRICE_TYPICAL,0); // МА_35 DALYN GUPPY MMA
double MA_40=iMA(NULL,L,40,0,MODE_EMA,PRICE_TYPICAL,0); // МА_40 DALYN GUPPY MMA
double MA_45=iMA(NULL,L,45,0,MODE_EMA,PRICE_TYPICAL,0); // МА_45 DALYN GUPPY MMA
double MA_50=iMA(NULL,L,50,0,MODE_EMA,PRICE_TYPICAL,0); // МА_50 DALYN GUPPY MMA
double MA_60=iMA(NULL,L,60,0,MODE_EMA,PRICE_TYPICAL,0); // МА_60 DALYN GUPPY MMA
//-----------------------------------------------------------------------------------
HideTestIndicators(false);
for(int trade=OrdersTotal()-1; trade>=0; trade--)
{
if(OrderSelect(trade,SELECT_BY_POS,MODE_TRADES))
{
if(OrderSymbol()!=Symbol() || OrderMagicNumber()!=MagicNumber)
continue;
if(OrderSymbol()==Symbol() || OrderMagicNumber()==MagicNumber)
{
if(OrderType()==OP_BUY)
{
//--- should it be closed?
if(((MA_3==MA_5 && MA_5==MA_8 && MA_8==MA_10 && MA_10==MA_12 && MA_12==MA_15)
||(MA_30==MA_35 && MA_35==MA_40 && MA_40==MA_45 && MA_45==MA_50 && MA_50==MA_60))
||(Close[1]<=lowerBB))
if(!OrderClose(OrderTicket(),OrderLots(),OrderClosePrice(),3,Red))
Print("Did not close");
break;
Print(" CLOSE BY EXIT STRATEGY ");
//--- check for trailing stop
}
else // go to short position
{
//--- should it be closed?
if(((MA_3==MA_5 && MA_5==MA_8 && MA_8==MA_10 && MA_10==MA_12 && MA_12==MA_15)
||(MA_30==MA_35 && MA_35==MA_40 && MA_40==MA_45 && MA_45==MA_50 && MA_50==MA_60))
||(Close[1]<=lowerBB))
if(!OrderClose(OrderTicket(),OrderLots(),OrderClosePrice(),3,Red))
Print("Did not close");
break;
Print(" CLOSE BY EXIT STRATEGY ");
//--- check for trailing stop
}
}
}
}
return(0);
}
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| Trailing stop loss |
//+------------------------------------------------------------------+
// --------------- ----------------------------------------------------------- ------------------------
void Trail1()
{
total=OrdersTotal();
//--- it is important to enter the market correctly, but it is more important to exit it correctly...
for(int cnt=0; cnt<total; cnt++)
{
if(!OrderSelect(cnt,SELECT_BY_POS,MODE_TRADES))
continue;
if(OrderMagicNumber()!=MagicNumber)
continue;
if(OrderType()<=OP_SELL && // check for opened position
OrderSymbol()==Symbol()) // check for symbol
{
//--- long position is opened
if(OrderType()==OP_BUY)
{

//--- check for trailing stop
if(TrailingStop>0)
{
if(Bid-OrderOpenPrice()>pips*TrailingStop)
{
if(OrderStopLoss()<Bid-pips*TrailingStop)
{

RefreshRates();
stoploss=Bid-(pips*TrailingStop);
takeprofit=OrderTakeProfit();
double StopLevel=MarketInfo(Symbol(),MODE_STOPLEVEL)+MarketInfo(Symbol(),MODE_SPREAD);
if(stoploss<StopLevel*pips)
stoploss=StopLevel*pips;
string symbol=OrderSymbol();
double point=SymbolInfoDouble(symbol,SYMBOL_POINT);
if(MathAbs(OrderStopLoss()-stoploss)>point)
if((pips*TrailingStop)>(int)SymbolInfoInteger(_Symbol,SYMBOL_TRADE_FREEZE_LEVEL)*pips)

//--- modify order and exit
if(CheckStopLoss_Takeprofit(OP_BUY,stoploss,takeprofit))
if(OrderModifyCheck(OrderTicket(),OrderOpenPrice(),stoploss,takeprofit))
if(!OrderModify(OrderTicket(),OrderOpenPrice(),stoploss,takeprofit,0,Green))
Print("OrderModify error ",GetLastError());
return;
}
}
}
}
else // go to short position
{
//--- check for trailing stop
if(TrailingStop>0)
{
if((OrderOpenPrice()-Ask)>(pips*TrailingStop))
{
if((OrderStopLoss()>(Ask+pips*TrailingStop)) || (OrderStopLoss()==0))
{

RefreshRates();
stoploss=Ask+(pips*TrailingStop);
takeprofit=OrderTakeProfit();
double StopLevel=MarketInfo(Symbol(),MODE_STOPLEVEL)+MarketInfo(Symbol(),MODE_SPREAD);
if(stoploss<StopLevel*pips)
stoploss=StopLevel*pips;
if(takeprofit<StopLevel*pips)
takeprofit=StopLevel*pips;
string symbol=OrderSymbol();
double point=SymbolInfoDouble(symbol,SYMBOL_POINT);
if(MathAbs(OrderStopLoss()-stoploss)>point)
if((pips*TrailingStop)>(int)SymbolInfoInteger(_Symbol,SYMBOL_TRADE_FREEZE_LEVEL)*pips)

//--- modify order and exit
if(CheckStopLoss_Takeprofit(OP_SELL,stoploss,takeprofit))
if(OrderModifyCheck(OrderTicket(),OrderOpenPrice(),stoploss,takeprofit))
if(!OrderModify(OrderTicket(),OrderOpenPrice(),stoploss,takeprofit,0,Red))
Print("OrderModify error ",GetLastError());
return;
}
}
}
}
}
}
}
//+------------------------------------------------------------------+
//+---------------------------------------------------------------------------+
//| MOVE TO BREAK EVEN |
//+---------------------------------------------------------------------------+
void MOVETOBREAKEVEN()

{
for(int b=OrdersTotal()-1; b>=0; b--)
{
if(OrderSelect(b,SELECT_BY_POS,MODE_TRADES))
if(OrderMagicNumber()!=MagicNumber)
continue;
if(OrderSymbol()==Symbol())
if(OrderType()==OP_BUY)
if(Bid-OrderOpenPrice()>WHENTOMOVETOBE*pips)
if(OrderOpenPrice()>OrderStopLoss())
if(CheckStopLoss_Takeprofit(OP_SELL,OrderOpenPrice()+(PIPSTOMOVESL*pips),OrderTakeProfit()))
if(OrderModifyCheck(OrderTicket(),OrderOpenPrice(),OrderOpenPrice()+(PIPSTOMOVESL*pips),OrderTakeProfit()))
if(!OrderModify(OrderTicket(),OrderOpenPrice(),OrderOpenPrice()+(PIPSTOMOVESL*pips),OrderTakeProfit(),0,CLR_NONE))
Print("eror");
}

for(int s=OrdersTotal()-1; s>=0; s--)
{
if(OrderSelect(s,SELECT_BY_POS,MODE_TRADES))
if(OrderMagicNumber()!=MagicNumber)
continue;
if(OrderSymbol()==Symbol())
if(OrderType()==OP_SELL)
if(OrderOpenPrice()-Ask>WHENTOMOVETOBE*pips)
if(OrderOpenPrice()<OrderStopLoss())
if(CheckStopLoss_Takeprofit(OP_SELL,OrderOpenPrice()-(PIPSTOMOVESL*pips),OrderTakeProfit()))
if(OrderModifyCheck(OrderTicket(),OrderOpenPrice(),OrderOpenPrice()-(PIPSTOMOVESL*pips),OrderTakeProfit()))
if(!OrderModify(OrderTicket(),OrderOpenPrice(),OrderOpenPrice()-(PIPSTOMOVESL*pips),OrderTakeProfit(),0,CLR_NONE))
Print("eror");
}
}
//+------------------------------------------------------------------+
// NormalizeDouble |
//+------------------------------------------------------------------+
double NDTP(double val)
{
RefreshRates();
double SPREAD=MarketInfo(Symbol(),MODE_SPREAD);
double StopLevel=MarketInfo(Symbol(),MODE_STOPLEVEL);
if(val<StopLevel*pips+SPREAD*pips)
val=StopLevel*pips+SPREAD*pips;
return(NormalizeDouble(val, Digits));
// return(val);
}
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
double ND(double val)
{
return(NormalizeDouble(val, Digits));
}
//+------------------------------------------------------------------+
//| Checking the new values of levels before order modification |
//+------------------------------------------------------------------+
bool OrderModifyCheck(int ticket,double price,double sl,double tp)
{
//--- select order by ticket
if(OrderSelect(ticket,SELECT_BY_TICKET))
{
//--- point size and name of the symbol, for which a pending order was placed
string symbol=OrderSymbol();
double point=SymbolInfoDouble(symbol,SYMBOL_POINT);
//--- check if there are changes in the Open price
bool PriceOpenChanged=true;
int type=OrderType();
if(!(type==OP_BUY || type==OP_SELL))
{
PriceOpenChanged=(MathAbs(OrderOpenPrice()-price)>point);
}
//--- check if there are changes in the StopLoss level
bool StopLossChanged=(MathAbs(OrderStopLoss()-sl)>point);
//--- check if there are changes in the Takeprofit level
bool TakeProfitChanged=(MathAbs(OrderTakeProfit()-tp)>point);
//--- if there are any changes in levels
if(PriceOpenChanged || StopLossChanged || TakeProfitChanged)
return(true); // order can be modified
//--- there are no changes in the Open, StopLoss and Takeprofit levels
else
//--- notify about the error
PrintFormat("Order #%d already has levels of Open=%.5f SL=%.5f TP=%.5f",
ticket,OrderOpenPrice(),OrderStopLoss(),OrderTakeProfit());
}
//--- came to the end, no changes for the order
return(false); // no point in modifying
}
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
bool CheckStopLoss_Takeprofit(ENUM_ORDER_TYPE type,double SL,double TP)
{
//--- get the SYMBOL_TRADE_STOPS_LEVEL level
int stops_level=(int)SymbolInfoInteger(_Symbol,SYMBOL_TRADE_STOPS_LEVEL);
if(stops_level!=0)
{
PrintFormat("SYMBOL_TRADE_STOPS_LEVEL=%d: StopLoss and TakeProfit must"+
" not be nearer than %d points from the closing price",stops_level,stops_level);
}
//---
bool SL_check=false,TP_check=false;
//--- check only two order types
switch(type)
{
//--- Buy operation
case ORDER_TYPE_BUY:
{
//--- check the StopLoss
SL_check=(Bid-SL>stops_level*_Point);
if(!SL_check)
PrintFormat("For order %s StopLoss=%.5f must be less than %.5f"+
" (Bid=%.5f - SYMBOL_TRADE_STOPS_LEVEL=%d points)",
EnumToString(type),SL,Bid-stops_level*_Point,Bid,stops_level);
//--- check the TakeProfit
TP_check=(TP-Bid>stops_level*_Point);
if(!TP_check)
PrintFormat("For order %s TakeProfit=%.5f must be greater than %.5f"+
" (Bid=%.5f + SYMBOL_TRADE_STOPS_LEVEL=%d points)",
EnumToString(type),TP,Bid+stops_level*_Point,Bid,stops_level);
//--- return the result of checking
return(SL_check&&TP_check);
}
//--- Sell operation
case ORDER_TYPE_SELL:
{
//--- check the StopLoss
SL_check=(SL-Ask>stops_level*_Point);
if(!SL_check)
PrintFormat("For order %s StopLoss=%.5f must be greater than %.5f "+
" (Ask=%.5f + SYMBOL_TRADE_STOPS_LEVEL=%d points)",
EnumToString(type),SL,Ask+stops_level*_Point,Ask,stops_level);
//--- check the TakeProfit
TP_check=(Ask-TP>stops_level*_Point);
if(!TP_check)
PrintFormat("For order %s TakeProfit=%.5f must be less than %.5f "+
" (Ask=%.5f - SYMBOL_TRADE_STOPS_LEVEL=%d points)",
EnumToString(type),TP,Ask-stops_level*_Point,Ask,stops_level);
//--- return the result of checking
return(TP_check&&SL_check);
}
break;
}
//--- a slightly different function is required for pending orders
return false;
}
//+------------------------------------------------------------------+
////////////////////////////////////////////////////////////////////////////////////
int getOpenOrders()
{

int Orders=0;
for(int i=0; i<OrdersTotal(); i++)
{
if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES)==false)
{
continue;
}
if(OrderSymbol()!=Symbol() || OrderMagicNumber()!=MagicNumber)
{
continue;
}
Orders++;
}
return(Orders);
}
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| Calculate optimal lot size buy |
//+------------------------------------------------------------------+
double LotsOptimized1Mxs(double llots)
{
double lots=llots;
//--- minimal allowed volume for trade operations
double minlot=SymbolInfoDouble(Symbol(),SYMBOL_VOLUME_MIN);
if(lots<minlot)
{ lots=minlot; }
//--- maximal allowed volume of trade operations
double maxlot=SymbolInfoDouble(Symbol(),SYMBOL_VOLUME_MAX);
if(lots>maxlot)
{ lots=maxlot; }
//--- get minimal step of volume changing
double volume_step=SymbolInfoDouble(Symbol(),SYMBOL_VOLUME_STEP);
int ratio=(int)MathRound(lots/volume_step);
if(MathAbs(ratio*volume_step-lots)>0.0000001)
{ lots=ratio*volume_step;}
if(((AccountStopoutMode()==1) &&
(AccountFreeMarginCheck(Symbol(),OP_BUY,lots)>AccountStopoutLevel()))
|| ((AccountStopoutMode()==0) &&
((AccountEquity()/(AccountEquity()-AccountFreeMarginCheck(Symbol(),OP_BUY,lots))*100)>AccountStopoutLevel())))
return(lots);
/* else Print("StopOut level Not enough money for ",OP_SELL," ",lot," ",Symbol());*/
return(0);
}
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| Calculate optimal lot size buy |
//+------------------------------------------------------------------+
double LotsOptimizedMxs(double llots)
{
double lots=llots;
//--- minimal allowed volume for trade operations
double minlot=SymbolInfoDouble(Symbol(),SYMBOL_VOLUME_MIN);
if(lots<minlot)
{
lots=minlot;
Print("Volume is less than the minimal allowed ,we use",minlot);
}
//--- maximal allowed volume of trade operations
double maxlot=SymbolInfoDouble(Symbol(),SYMBOL_VOLUME_MAX);
if(lots>maxlot)
{
lots=maxlot;
Print("Volume is greater than the maximal allowed,we use",maxlot);
}
//--- get minimal step of volume changing
double volume_step=SymbolInfoDouble(Symbol(),SYMBOL_VOLUME_STEP);
int ratio=(int)MathRound(lots/volume_step);
if(MathAbs(ratio*volume_step-lots)>0.0000001)
{
lots=ratio*volume_step;

Print("Volume is not a multiple of the minimal step ,we use the closest correct volume ",ratio*volume_step);
}

return(lots);

}
//+------------------------------------------------------------------+
//| Check the correctness of the order volume |
//+------------------------------------------------------------------+
bool CheckVolumeValue(double volume/*,string &description*/)

{
double lot=volume;
int orders=OrdersHistoryTotal(); // history orders total
int losses=0; // number of losses orders without a break
//--- select lot size
//--- maximal allowed volume of trade operations
double max_volume=SymbolInfoDouble(Symbol(),SYMBOL_VOLUME_MAX);
if(lot>max_volume)

Print("Volume is greater than the maximal allowed ,we use",max_volume);
// return(false);

//--- minimal allowed volume for trade operations
double minlot=SymbolInfoDouble(Symbol(),SYMBOL_VOLUME_MIN);
if(lot<minlot)

Print("Volume is less than the minimal allowed ,we use",minlot);
// return(false);

//--- get minimal step of volume changing
double volume_step=SymbolInfoDouble(Symbol(),SYMBOL_VOLUME_STEP);
int ratio=(int)MathRound(lot/volume_step);
if(MathAbs(ratio*volume_step-lot)>0.0000001)
{
Print("Volume is not a multiple of the minimal step ,we use, the closest correct volume is %.2f",
volume_step,ratio*volume_step);
// return(false);
}
// description="Correct volume value";
return(true);
}
//+------------------------------------------------------------------+
bool CheckMoneyForTrade(string symb,double lots,int type)
{
double free_margin=AccountFreeMarginCheck(symb,type,lots);
//-- if there is not enough money
if(free_margin>0)
{
if((AccountStopoutMode()==1) &&
(AccountFreeMarginCheck(symb,type,lots)<AccountStopoutLevel()))
{
Print("StopOut level Not enough money ", type," ",lots," ",Symbol());
return(false);
}
if(AccountEquity()-AccountFreeMarginCheck(Symbol(),type,lots)==0)
{
Print("StopOut level Not enough money ", type," ",lots," ",Symbol());
return(false);
}
if((AccountStopoutMode()==0) &&
((AccountEquity()/(AccountEquity()-AccountFreeMarginCheck(Symbol(),type,lots))*100)<AccountStopoutLevel()))
{
Print("StopOut level Not enough money ", type," ",lots," ",Symbol());
return(false);
}
}
else
if(free_margin<0)
{
string oper=(type==OP_BUY)? "Buy":"Sell";
Print("Not enough money for ",oper," ",lots," ",symb," Error code=",GetLastError());
return(false);
}
//--- checking successful
return(true);
}
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| Calculate optimal lot size buy |
//+------------------------------------------------------------------+
double LotsOptimized(double llots)
{
double lot=llots;
int orders=OrdersHistoryTotal(); // history orders total
int losses=0; // number of losses orders without a break
//--- calcuulate number of losses orders without a break
if(IncreaseFactor>0)
{
for(int i=orders-1; i>=0; i--)
{
if(OrderSelect(i,SELECT_BY_POS,MODE_HISTORY)==false)
{
Print("Error in history!");
break;
}
if(OrderSymbol()!=Symbol())
continue;
//---
if(OrderProfit()>0)
break;
if(OrderProfit()<0)
losses++;
}
if(losses>1)
// lot=NormalizeDouble(lot+lot*losses/IncreaseFactor,1);
lot=AccountFreeMargin()*IncreaseFactor/1000.0;
}
//--- minimal allowed volume for trade operations
double minlot=SymbolInfoDouble(Symbol(),SYMBOL_VOLUME_MIN);
if(lot<minlot)
{
lot=minlot;
Print("Volume is less than the minimal allowed ,we use",minlot);
}
// lot=minlot;

//--- maximal allowed volume of trade operations
double maxlot=SymbolInfoDouble(Symbol(),SYMBOL_VOLUME_MAX);
if(lot>maxlot)
{
lot=maxlot;
Print("Volume is greater than the maximal allowed,we use",maxlot);
}
// lot=maxlot;

//--- get minimal step of volume changing
double volume_step=SymbolInfoDouble(Symbol(),SYMBOL_VOLUME_STEP);
int ratio=(int)MathRound(lot/volume_step);
if(MathAbs(ratio*volume_step-lot)>0.0000001)
{
lot=ratio*volume_step;

Print("Volume is not a multiple of the minimal step ,we use the closest correct volume ",ratio*volume_step);
}
return(lot);

}
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| Ask Stochastic |
//+------------------------------------------------------------------+
int CheckStochastic()
{
//CHOCurrent = iCustom(NULL,0,"CHO",CHOTime,3,0,1,0);
// CHOPrevious = iCustom(NULL,0,"CHO",CHOTime,3,0,1,1);

// STOCHASTIC VALUE
STOCHCurrent = iStochastic(NULL,0,5,3,3,MODE_SMA,0,MODE_MAIN,0);
STOCHPrevious = iStochastic(NULL,0,5,3,3,MODE_SMA,0,MODE_MAIN,1);

// STOCH_Status = DECISION_UNKNOWN;

if(STOCHCurrent>50 && STOCHCurrent<88)
{
if(CHOCurrent>10)
{
STOCH_Status = DECISION_BUY;

}
else
if(CHOCurrent<-10)
{
STOCH_Status = DECISION_SELL;

}
}
else
if(STOCHCurrent<=12)
{
STOCH_Status = DECISION_SELL;

}
else
if(STOCHCurrent>=88)
{
STOCH_Status = DECISION_BUY;

}
else
if(STOCHCurrent<50 && STOCHCurrent>12)
{
if(CHOCurrent>10)
{
STOCH_Status = DECISION_BUY;

}
else
if(CHOCurrent<-10)
{
STOCH_Status = DECISION_SELL;

}
}
return (0);
}

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



//+------------------------------------------------------------------+
//| Ask CCI |
//+------------------------------------------------------------------+
int CheckCCI()
{
// CCI VALUE
CCICurrent = iCCI(NULL,0,20,PRICE_TYPICAL,0);
CCIPrevious = iCCI(NULL,0,20,PRICE_TYPICAL,1);
// CCI_Status = DECISION_UNKNOWN;

if((CCICurrent>CCIPrevious)&&(CCICurrent<75))
{
CCI_Status = DECISION_BUY;

}
else
if((CCICurrent<CCIPrevious)&&(CCICurrent>=-75))
{
CCI_Status = DECISION_SELL;

}
return (0);
}

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

//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
int CheckMA()
{

double MA_1_t=iMA(NULL,L,FastMA,0,MODE_LWMA,PRICE_TYPICAL,1); // МА_1
double MA_2_t=iMA(NULL,L,SlowMA,0,MODE_LWMA,PRICE_TYPICAL,1); // МА_2
ATR_Status = DECISION_UNKNOWN;

if(MA_1_t>MA_2_t)
{
MA_Status = DECISION_BUY;

}
else
if(MA_1_t<MA_2_t)
{
MA_Status = DECISION_SELL;

}
return (0);
}

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

//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
int CheckATR()
{

ATRCurrent = iATR(NULL,0,12,1);
ATRPrevious = iATR(NULL,0,12,0);
ATR_Status = DECISION_UNKNOWN;

if(ATRCurrent>ATRPrevious)
{
RSI_Status = DECISION_BUY;

}
else
if(ATRCurrent<ATRPrevious)
{
ATR_Status = DECISION_SELL;

}
return (0);
}

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

//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
int CheckOSMA()
{

OSMACurrent = iOsMA(NULL,0,12,26,9,PRICE_OPEN,1);

OSMA_Status = DECISION_UNKNOWN;

if(OSMACurrent>0)
{
OSMA_Status = DECISION_BUY;

}
else
if(OSMACurrent<0)
{
OSMA_Status = DECISION_SELL;

}
return (0);
}

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

//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
int CheckMACD()
{

double MacdMAIN0=iMACD(NULL,0,12,26,9,PRICE_CLOSE,MODE_MAIN,1);
double MacdSIGNAL0=iMACD(NULL,0,12,26,9,PRICE_CLOSE,MODE_SIGNAL,1);
MACDStatus = DECISION_UNKNOWN;

if((MacdMAIN0>0 && MacdMAIN0>MacdSIGNAL0) || (MacdMAIN0<0 && MacdMAIN0>MacdSIGNAL0))
{
MACDStatus = DECISION_BUY;

}
else
if((MacdMAIN0>0 && MacdMAIN0<MacdSIGNAL0) || (MacdMAIN0<0 && MacdMAIN0<MacdSIGNAL0))
{
MACDStatus = DECISION_SELL;

}
return (0);
}

//-------------------------------------------------------------------
//+------------------------------------------------------------------+
//| Trading |
//+------------------------------------------------------------------+
int Trade1()
{
// begin to trade
// Looking for open orders
//--------------------------------------------------------------------------------------------------
double MomLevel=MathAbs(100-iMomentum(NULL,0,14,PRICE_CLOSE,1));
double MomLevel1=MathAbs(100 - iMomentum(NULL,0,14,PRICE_CLOSE,2));
double MomLevel2=MathAbs(100 - iMomentum(NULL,0,14,PRICE_CLOSE,3));
double MomLevel3=MathAbs(100 - iMomentum(NULL,0,14,PRICE_CLOSE,0));
//--------------------------------------------------------------------------------------------------
ToSell=0;
ToBuy =0;
//FindSymbolOrder();

CheckCCI();
CheckMA();
CheckStochastic();
CheckATR();
CheckOSMA();
CheckMACD();
//+--------------------------------------------------------------------------+
if(ATR_Status==DECISION_BUY)
{
ToBuy=ToBuy+1;
ATR_Status=DECISION_UNKNOWN;
}
else
if(ATR_Status==DECISION_SELL)
{
ToSell=ToSell+1;
ATR_Status=DECISION_UNKNOWN;
}

//+--------------------------------------------------------------------------+
if(OSMA_Status==DECISION_BUY)
{
ToBuy=ToBuy+1;
OSMA_Status=DECISION_UNKNOWN;
}
else
if(OSMA_Status==DECISION_SELL)
{
ToSell=ToSell+1;
OSMA_Status=DECISION_UNKNOWN;
}

//+--------------------------------------------------------------------------+
if(MACDStatus==DECISION_BUY)
{
ToBuy=ToBuy+1;
MACDStatus=DECISION_UNKNOWN;
}
else
if(MACDStatus==DECISION_SELL)
{
ToSell=ToSell+1;
MACDStatus=DECISION_UNKNOWN;
}

//+--------------------------------------------------------------------------+

if(CCI_Status==DECISION_BUY)
{
ToBuy=ToBuy+1;
CCI_Status=DECISION_UNKNOWN;
}
else
if(CCI_Status==DECISION_SELL)
{
ToSell=ToSell+1;
CCI_Status=DECISION_UNKNOWN;
}
//+--------------------------------------------------------------------------+
//+--------------------------------------------------------------------------+
if(MA_Status==DECISION_BUY)
{
ToBuy=ToBuy+1;
MA_Status=DECISION_UNKNOWN;
}
else
if(MA_Status==DECISION_SELL)
{
ToSell=ToSell+1;
MA_Status=DECISION_UNKNOWN;
}

//+--------------------------------------------------------------------------+


if(RSI_Status==DECISION_BUY)
{
ToBuy=ToBuy+1;
RSI_Status=DECISION_UNKNOWN;
}
else
if(RSI_Status==DECISION_SELL)
{
ToSell=ToSell+1;
RSI_Status=DECISION_UNKNOWN;
}
//+--------------------------------------------------------------------------+
if(STOCH_Status==DECISION_BUY)
{
ToBuy=ToBuy+1;
STOCH_Status=DECISION_UNKNOWN;
}
else
if(STOCH_Status==DECISION_SELL)
{
ToSell=ToSell+1;
STOCH_Status=DECISION_UNKNOWN;
}
//+--------------------------------------------------------------------------+
//-----------------------------------------------------------------
if(ToSell>ToBuy&&(MomLevel<Mom_Sell || MomLevel1<Mom_Sell || MomLevel2<Mom_Sell))
{
Decision = DECISION_SELL ;
return(2);
}
else
if(ToSell<ToBuy &&(MomLevel<Mom_Buy || MomLevel1<Mom_Buy || MomLevel2<Mom_Buy))
{
Decision = DECISION_BUY ;
return(1);
}
else
{
Decision = DECISION_UNKNOWN;
}
return(0);

}



//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
int CountTrades()
{
int count=0;
for(int trade=OrdersTotal()-1; trade>=0; trade--)
{
if(!OrderSelect(trade,SELECT_BY_POS,MODE_TRADES))
Print("Error");
if(OrderSymbol()!=Symbol() || OrderMagicNumber()!=MagicNumber)
continue;
if(OrderSymbol()==Symbol() && OrderMagicNumber()==MagicNumber)
if(OrderType()==OP_SELL || OrderType()==OP_BUY)
count++;
}
return (count);
}
//+------------------------------------------------------------------+
double AccountEquityHigh()
{
if(CountTrades()==0)
AccountEquityHighAmt=AccountEquity();
if(AccountEquityHighAmt<PrevEquity)
AccountEquityHighAmt=PrevEquity;
else
AccountEquityHighAmt=AccountEquity();
PrevEquity=AccountEquity();
return (AccountEquityHighAmt);
}
//+------------------------------------------------------------------+
double CalculateProfit()
{
double Profit=0;
for(int cnt=OrdersTotal()-1; cnt>=0; cnt--)
{
if(!OrderSelect(cnt,SELECT_BY_POS,MODE_TRADES))
Print("Error");
if(OrderSymbol()!=Symbol() || OrderMagicNumber()!=MagicNumber)
continue;
if(OrderSymbol()==Symbol() && OrderMagicNumber()==MagicNumber)
if(OrderType()==OP_BUY || OrderType()==OP_SELL)
Profit+=OrderProfit();
}
return (Profit);
}
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
void CloseThisSymbolAll()
{
double CurrentPairProfit=CalculateProfit();
for(int trade=OrdersTotal()-1; trade>=0; trade--)
{
if(!OrderSelect(trade,SELECT_BY_POS,MODE_TRADES))
Print("Error");
if(OrderSymbol()==Symbol())
{
if(OrderSymbol()==Symbol() && OrderMagicNumber()==MagicNumber)
{
if(OrderType() == OP_BUY)
if(!OrderClose(OrderTicket(), OrderLots(), Bid, 3, Blue))
Print("Error");
if(OrderType() == OP_SELL)
if(!OrderClose(OrderTicket(), OrderLots(), Ask, 3, Red))
Print("Error");
}
Sleep(1000);
if(UseEquityStop)
{
if(CurrentPairProfit>0.0 && MathAbs(CurrentPairProfit)>TotalEquityRisk/100.0*AccountEquityHigh())
{
return;

}
}

}
}
}
//+------------------------------------------------------------------+
 
Last edited by a moderator:
Code:
If you want code to look better and not force everyone to
scroll through many lines to get to the next post,
        you can use CODE tags (e.g., to preserve indentation

        and other     white space     such as blank lines).
Then



































        use
1615940129112.png
 
Last edited:
Top