MT4 EA converted to a cBot

Created at 19 Aug 2021

hennies

Joined 12.04.2021

Status

Closed

Budget

160.00 USD

Payment Method

Direct Payment

Job Description

I would like the following MT4 code to be converted to a cBot:-

//+------------------------------------------------------------------+
//+ Code generated using FxPro Quant 2.1.4 |
//+------------------------------------------------------------------+
#property strict

#define __STRATEGY_MAGIC 1001000000
#define __SLEEP_AFTER_EXECUTION_FAIL 400

struct InputsStr
{
string _Currency; // Symbol
string _TimeFrame; // TimeFrame
string _Slowing; // Slowing
string _Whole_Number_Input; // Period
string _Grid_Points; // Grid Points
string _SL_Percentage; // SL Percentage
string _RSI_Buy_Limit; // RSI Buy Limit
string _Sell_TP_in_Points; // Sell TP in Points
string _Max_Days; // Max Days
string _Stoc_Buy_Limit; // Stoc Buy Limit
string _Mom_Buy_Limit; // Mom Buy Limit
string _D_Period; // D Period
string _Stoc_Sell_Limit; // Stoc Sell Limit
string _RSI_Sell_Limit; // RSI Sell Limit
string _Mom_Sell_Limit; // Mom Sell Limit
string _Buy_TP_in_Points; // Buy TP in Points
string _Max_Open_Trades; // Max Open Trades
string _Lot_Percentage; // Lot Percentage
};
struct Inputs
{
string _Currency; // Symbol
string _TimeFrame; // TimeFrame
int _Slowing; // Slowing
int _Whole_Number_Input; // Period
int _Grid_Points; // Grid Points
double _SL_Percentage; // SL Percentage
int _RSI_Buy_Limit; // RSI Buy Limit
int _Sell_TP_in_Points; // Sell TP in Points
int _Max_Days; // Max Days
int _Stoc_Buy_Limit; // Stoc Buy Limit
double _Mom_Buy_Limit; // Mom Buy Limit
int _D_Period; // D Period
int _Stoc_Sell_Limit; // Stoc Sell Limit
int _RSI_Sell_Limit; // RSI Sell Limit
double _Mom_Sell_Limit; // Mom Sell Limit
int _Buy_TP_in_Points; // Buy TP in Points
int _Max_Open_Trades; // Max Open Trades
double _Lot_Percentage; // Lot Percentage
};

//Default Input variables
string _Currency ;
int _TimeFrame;
int _Slowing;
int _Whole_Number_Input;
int _Grid_Points ;
double _SL_Percentage ;
int _RSI_Buy_Limit ;
int _Sell_TP_in_Points;
int _Max_Days ;
int _Stoc_Buy_Limit ;
double _Mom_Buy_Limit;
int _D_Period;
int _Stoc_Sell_Limit;
int _RSI_Sell_Limit ;
double _Mom_Sell_Limit;
int _Buy_TP_in_Points;
int _Max_Open_Trades ;
double _Lot_Percentage;

//Global declaration
double _Momentum;
double _Stochastic_3;
double _RSI;
bool _Compare_7;
bool _Compare_10;
bool _Compare_1;
bool _Compare_9;
bool _Compare_11;
double _Arithmetic;
bool _Compare_12;
bool _Compare_2;

Inputs inputsAct[] ;
InputsStr inputs[];

// Global Variables
input string _FileName="MRS14.csv" ; // Input File
input int _GlobalMaxOrders=20;

//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
int init()
{
if(ReadCSVFile())
{
if(ArraySize(inputsAct)<=0)
return INIT_FAILED;
}
else
{
return INIT_FAILED ;
}
return(0);
}

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

for(int i=0; i<ArraySize(inputsAct); i++)
{
SetSettings(inputsAct[i]._Currency);
//Local declaration
bool _Close_Position_1 = false;
bool _Sell = false;
bool _Buy = false;
bool _Buy_2 = false;
bool _Sell_2 = false;
_Momentum = iMomentum(_Currency,_TimeFrame, _Whole_Number_Input, 0, 0);
_Stochastic_3 = iStochastic(_Currency, _TimeFrame, _Whole_Number_Input, _D_Period, _Slowing, 0, 0, 0, 0);
_RSI = iRSI(_Currency, _TimeFrame, _Whole_Number_Input,0, 0);

_Compare_7 = (_RSI > _RSI_Sell_Limit);
_Compare_10 = (_Momentum > _Mom_Sell_Limit);
_Compare_1 = (_RSI < _RSI_Buy_Limit);
_Compare_9 = (_Momentum < _Mom_Buy_Limit);
_Compare_11 = (Number_of_Open_Trades(1,_Currency) < _Max_Open_Trades);
_Arithmetic = ((_Grid_Points *
(-1)) *
(Number_of_Open_Trades(1,_Currency)));
_Compare_12 = (_Stochastic_3 > _Stoc_Sell_Limit);
_Compare_2 = (_Stochastic_3 < _Stoc_Buy_Limit);

if((__OpenTime(1, _Currency) + 24*60*60 * (_Max_Days) < TimeCurrent()))
{
_Close_Position_1 = __isOpenedPosition(1, _Currency);
if(_Close_Position_1)
{
int ticket = OrderTicket();
int type = OrderType();
double lots = OrderLots();
string sym = OrderSymbol();
_Close_Position_1 = OrderClose(ticket, lots, MarketInfo(sym, MODE_BID) + MarketInfo(sym, MODE_SPREAD) * MarketInfo(sym, MODE_POINT) * (type==1 ? 1:0), 0);
}
}

if(GetGlobalOrders()>=_GlobalMaxOrders)
return 0 ;

if(((_Compare_7 &&
(_Compare_12 &&
!__selectOrderBySymbol(_Currency))) &&
_Compare_10))

_Sell = Sell(_Currency,1, ((_Lot_Percentage *
(AccountFreeMargin())) /
(100000)), 0, ((AccountFreeMargin() /
((100 /
(_SL_Percentage)))) /
(((_Lot_Percentage *
(AccountFreeMargin())) /
(100000)))), 0, _Sell_TP_in_Points, 5, _Max_Open_Trades, 0, "");

if((((_Compare_2 &&
!__selectOrderBySymbol(_Currency)) &&
_Compare_1) &&
_Compare_9))

_Buy = Buy(_Currency,1, ((_Lot_Percentage *
(AccountFreeMargin())) /
(100000)), 0, ((AccountFreeMargin() /
((100 /
(_SL_Percentage)))) /
(((_Lot_Percentage *
(AccountFreeMargin())) /
(100000)))), 0, _Buy_TP_in_Points, 5, _Max_Open_Trades, 0, "");

if((((((__selectOrderBySymbol(_Currency) &&
((_Arithmetic < 0) &&
(__ProfitPoints(1, _Currency) < _Arithmetic))) &&
_Compare_11) &&
_Compare_2) &&
_Compare_1) &&
_Compare_9))

_Buy_2 = Buy(_Currency,1, ((_Lot_Percentage *
(AccountFreeMargin())) /
(100000)), 0, ((AccountFreeMargin() /
((100 /
(_SL_Percentage)))) /
(((_Lot_Percentage *
(AccountFreeMargin())) /
(100000)))), 0, _Buy_TP_in_Points, 5, _Max_Open_Trades, 0, "");

if((((((__selectOrderBySymbol(_Currency) &&
((_Arithmetic < 0) &&
(__ProfitPoints(1, _Currency) < _Arithmetic))) &&
_Compare_11) &&
_Compare_12) &&
_Compare_7) &&
_Compare_10))
_Sell_2 = Sell(_Currency,1, ((_Lot_Percentage *
(AccountFreeMargin())) /
(100000)), 0, ((AccountFreeMargin() /
((100 /
(_SL_Percentage)))) /
(((_Lot_Percentage *
(AccountFreeMargin())) /
(100000)))), 0, _Sell_TP_in_Points, 5, _Max_Open_Trades, 0, "");
}

return(0);
}

//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool __selectOrderBySymbol(string symbol)
{
for(int i = 0; i < OrdersTotal(); i++)
{
if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES) && OrderSymbol() == symbol)
return(true);
}
return(false);
}

//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool __selectOrderByMagic(int magic, string symbol)
{
for(int i = 0; i < OrdersTotal(); i++)
{
if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES) && OrderMagicNumber() == __STRATEGY_MAGIC + magic && OrderSymbol() == symbol)
return(true);
}
return(false);
}

//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
datetime __OpenTime(int magic, string symbol)
{
if(!__selectOrderByMagic(magic, symbol))
return(0);
return(OrderOpenTime());
}

//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
double __ProfitPoints(int magic, string symbol)
{
if(!__selectOrderByMagic(magic, symbol))
return(0);
if(OrderType() == OP_BUY)
return ((MarketInfo(OrderSymbol(),MODE_BID) - OrderOpenPrice())/MarketInfo(OrderSymbol(),MODE_POINT));
else
if(OrderType() == OP_SELL)
return ((OrderOpenPrice() - (MarketInfo(OrderSymbol(),MODE_ASK)))/MarketInfo(OrderSymbol(),MODE_POINT));
return (0);
}

//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool __isOpenedPosition(int magic, string symbol)
{
if(!__selectOrderByMagic(magic, symbol))
return(false);
return(OrderType()==OP_BUY || OrderType()==OP_SELL);
}

//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
int __Ticket(int magic, string symbol)
{
if(!__selectOrderByMagic(magic, symbol))
return(0);
return(OrderTicket());
}

//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
int Number_of_Open_Trades(int MagicIndex, string symbol)
{
int res = 0;
for(int i=OrdersTotal()-1; i>=0; i--)
{
if(!OrderSelect(i, SELECT_BY_POS))
continue;
if(OrderMagicNumber() != __STRATEGY_MAGIC + MagicIndex || OrderSymbol() != symbol)
continue;
res ++;
}
return (res);
}

//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool Sell(string symbol ,int MagicIndex, double Lots, int StopLossMethod, double StopLossPoints, int TakeProfitMethod, double TakeProfitPoints, int Slippage, int MaxOpenTrades,
int MaxFrequencyMins, string TradeComment)
{
int digits=(int)MarketInfo(symbol,MODE_DIGITS);
double points=MarketInfo(symbol,MODE_POINT);
double bid=MarketInfo(symbol,MODE_BID);
double ask=MarketInfo(symbol,MODE_ASK);

static double pipSize = 0;
if(pipSize == 0)
pipSize = points * (1 + 9 * (digits == 3 || digits == 5));

double sl = 0, tp = 0;
double stopLossPoints = 0, takeProfitPoints = 0;

int numberOfOpenTrades = 0;

for(int i=OrdersTotal()-1; i>=0; i--)
{
if(!OrderSelect(i, SELECT_BY_POS))
continue;
if(OrderMagicNumber() != __STRATEGY_MAGIC + MagicIndex || OrderSymbol() != symbol)
continue;
numberOfOpenTrades ++;
}

if(MaxOpenTrades > 0 && numberOfOpenTrades >= MaxOpenTrades)
return(false);

if(MaxFrequencyMins > 0)
{
int recentSeconds = MaxFrequencyMins * 60;

int hstTotal=OrdersHistoryTotal();

for(int i=hstTotal-1; i>=0; i--)
{
if(!OrderSelect(i,SELECT_BY_POS,MODE_HISTORY))
continue;
if(OrderMagicNumber() != __STRATEGY_MAGIC + MagicIndex || OrderSymbol() != symbol)
continue;
if(TimeCurrent() - OrderOpenTime() < recentSeconds)
return(false);
break;
}
}

if(Lots < MarketInfo(symbol,MODE_MINLOT))
return(false);

if(AccountFreeMarginCheck(symbol, OP_SELL,Lots) <= 0)
{
Print("Sell order error: insufficient capital");
return(false);
}

if(StopLossPoints > 0)
{
if(StopLossMethod == 0)
{
sl = NormalizeDouble(bid + StopLossPoints * points, digits);
stopLossPoints = StopLossPoints;
}
else
if(StopLossMethod == 1)
{
sl = NormalizeDouble(bid + StopLossPoints * pipSize, digits);
stopLossPoints = StopLossPoints * (1 + 9 * (digits == 3 || digits == 5));
}
else
{
sl = StopLossPoints;
stopLossPoints = (sl - bid)/points;
}
}

if(TakeProfitPoints > 0)
{
if(TakeProfitMethod == 0)
{
tp = NormalizeDouble(bid - TakeProfitPoints * points, digits);
takeProfitPoints = TakeProfitPoints;
}
else
if(TakeProfitMethod == 1)
{
tp = NormalizeDouble(bid - TakeProfitPoints * pipSize, digits);
takeProfitPoints = TakeProfitPoints * (1 + 9 * (digits == 3 || digits == 5));
}
else
{
tp = TakeProfitPoints;
takeProfitPoints = (bid - tp)/Point;
}
}

double stopLevel = MarketInfo(symbol,MODE_STOPLEVEL) + MarketInfo(symbol,MODE_SPREAD);

if((sl > 0 && stopLossPoints <= stopLevel) || (tp > 0 && takeProfitPoints <= stopLevel))
{
Print("Cannot Sell: Stop loss and take profit must be at least "
+ DoubleToStr(MarketInfo(symbol,MODE_STOPLEVEL) + MarketInfo(symbol,MODE_SPREAD),0)
+ " points away from the current price");
return (false);
}

RefreshRates();
int result = OrderSend(symbol, OP_SELL, Lots, bid, Slippage, sl, tp, "FxProQuant" + "(" + WindowExpertName() + ") " + TradeComment,__STRATEGY_MAGIC + MagicIndex);

if(result == -1)
{
Print("Failed to Sell: " + IntegerToString(GetLastError()));
Sleep(__SLEEP_AFTER_EXECUTION_FAIL);
return(false);
}

return(true);
}

//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool Buy(string symbol ,int MagicIndex, double Lots, int StopLossMethod, double StopLossPoints, int TakeProfitMethod, double TakeProfitPoints, int Slippage, int MaxOpenTrades,
int MaxFrequencyMins, string TradeComment)
{
int digits=(int)MarketInfo(symbol,MODE_DIGITS);
double points=MarketInfo(symbol,MODE_POINT);
double bid=MarketInfo(symbol,MODE_BID);
double ask=MarketInfo(symbol,MODE_ASK);

static double pipSize = 0;
if(pipSize == 0)
pipSize = points * (1 + 9 * (digits == 3 || digits == 5));

double sl = 0, tp = 0;
double stopLossPoints = 0, takeProfitPoints = 0;

int numberOfOpenTrades = 0;

if(MaxOpenTrades > 0 && numberOfOpenTrades >= MaxOpenTrades)
return(false);

if(MaxFrequencyMins > 0)
{
int recentSeconds = MaxFrequencyMins * 60;

int hstTotal=OrdersHistoryTotal();

for(int i=hstTotal-1; i>=0; i--)
{
if(!OrderSelect(i,SELECT_BY_POS,MODE_HISTORY))
continue;
if(OrderMagicNumber() != __STRATEGY_MAGIC + MagicIndex || OrderSymbol() !=symbol)
continue;
if(TimeCurrent() - OrderOpenTime() < recentSeconds)
return(false);
break;
}
}

if(Lots < MarketInfo(symbol,MODE_MINLOT))
return(false);

if(AccountFreeMarginCheck(symbol, OP_SELL,Lots) <= 0)
{
Print("Buy error: insufficient capital");
return(false);
}

if(StopLossPoints > 0)
{
if(StopLossMethod == 0)
{
sl = NormalizeDouble(ask - StopLossPoints * points, digits);
stopLossPoints = StopLossPoints;
}
else
if(StopLossMethod == 1)
{
sl = NormalizeDouble(ask - StopLossPoints * pipSize, digits);
stopLossPoints = StopLossPoints * (1 + 9 * (digits == 3 || digits == 5));
}
else
{
sl = StopLossPoints;
stopLossPoints = (ask - sl)/Point;
}
}

if(TakeProfitPoints > 0)
{
if(TakeProfitMethod == 0)
{
tp = NormalizeDouble(ask + TakeProfitPoints * points, digits);
takeProfitPoints = TakeProfitPoints;
}
else
if(TakeProfitMethod == 1)
{
tp = NormalizeDouble(ask + TakeProfitPoints * pipSize, digits);
takeProfitPoints = TakeProfitPoints * (1 + 9 * (digits == 3 || digits == 5));
}
else
{
tp = TakeProfitPoints;
takeProfitPoints = (tp - ask)/Point;
}
}

double stopLevel = MarketInfo(symbol,MODE_STOPLEVEL) + MarketInfo(symbol,MODE_SPREAD);

if((sl > 0 && stopLossPoints <= stopLevel) || (tp > 0 && takeProfitPoints <= stopLevel))
{
Print("Cannot Buy: Stop loss and take profit must be at least "
+ DoubleToStr(MarketInfo(symbol,MODE_STOPLEVEL) + MarketInfo(symbol,MODE_SPREAD),0)
+ " points away from the current price");
return (false);
}

RefreshRates();
int result = OrderSend(symbol, OP_BUY, Lots, ask, Slippage, sl, tp, "FxProQuant" + "(" + WindowExpertName() + ") " + TradeComment, __STRATEGY_MAGIC + MagicIndex);

if(result == -1)
{
Print("Failed to Buy: " + IntegerToString(GetLastError()));
Sleep(__SLEEP_AFTER_EXECUTION_FAIL);
return(false);
}

return(true);
}

//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool ReadCSVFile()
{
if(!FileIsExist(_FileName))
return false ;

int handle=FileOpen(_FileName,FILE_CSV|FILE_READ,";") ;
int line=0;
if(handle!=INVALID_HANDLE)
{
while(!FileIsEnding(handle))
{
ArrayResize(inputs,line+1);
inputs[line]._Currency=FileReadString(handle);
inputs[line]._TimeFrame=FileReadString(handle);
inputs[line]._Slowing=FileReadString(handle);
inputs[line]._Whole_Number_Input=FileReadString(handle);
inputs[line]._Grid_Points=FileReadString(handle);
inputs[line]._SL_Percentage=FileReadString(handle);
inputs[line]._RSI_Buy_Limit=FileReadString(handle);
inputs[line]._Sell_TP_in_Points=FileReadString(handle);
inputs[line]._Max_Days=FileReadString(handle);
inputs[line]._Stoc_Buy_Limit=FileReadString(handle);
inputs[line]._Mom_Buy_Limit=FileReadString(handle);
inputs[line]._D_Period=FileReadString(handle);
inputs[line]._Stoc_Sell_Limit=FileReadString(handle);
inputs[line]._RSI_Sell_Limit=FileReadString(handle); ;
inputs[line]._Mom_Sell_Limit=FileReadString(handle);
inputs[line]._Buy_TP_in_Points=FileReadString(handle);
inputs[line]._Max_Open_Trades=FileReadString(handle);
inputs[line]._Lot_Percentage=FileReadString(handle);
line++ ;
}
FileClose(handle);
}
else
{
return false ;
}

ArrayResize(inputsAct,ArraySize(inputs)-1);
for(int i=0; i<ArraySize(inputsAct); i++)
{
inputsAct[i]._Currency=inputs[i+1]._Currency;
inputsAct[i]._TimeFrame=inputs[i+1]._TimeFrame;
inputsAct[i]._Slowing=(int)inputs[i+1]._Slowing;
inputsAct[i]._Whole_Number_Input=(int)inputs[i+1]._Whole_Number_Input;
inputsAct[i]._Grid_Points=(int)inputs[i+1]._Grid_Points;
inputsAct[i]._SL_Percentage=StringToDouble(inputs[i+1]._SL_Percentage);
inputsAct[i]._RSI_Buy_Limit=(int)inputs[i+1]._RSI_Buy_Limit;
inputsAct[i]._Sell_TP_in_Points=(int)inputs[i+1]._Sell_TP_in_Points;
inputsAct[i]._Max_Days=(int)inputs[i+1]._Max_Days;
inputsAct[i]._Stoc_Buy_Limit=(int)inputs[i+1]._Stoc_Buy_Limit;
inputsAct[i]._Mom_Buy_Limit=StringToDouble(inputs[i+1]._Mom_Buy_Limit);
inputsAct[i]._D_Period=(int)inputs[i+1]._D_Period;
inputsAct[i]._Stoc_Sell_Limit=(int)inputs[i+1]._Stoc_Sell_Limit;
inputsAct[i]._RSI_Sell_Limit=(int)inputs[i+1]._RSI_Sell_Limit;
inputsAct[i]._Mom_Sell_Limit=StringToDouble(inputs[i+1]._Mom_Sell_Limit);
inputsAct[i]._Buy_TP_in_Points=(int)inputs[i+1]._Buy_TP_in_Points;
inputsAct[i]._Max_Open_Trades=(int)inputs[i+1]._Max_Open_Trades;
inputsAct[i]._Lot_Percentage=StringToDouble(inputs[i+1]._Lot_Percentage) ;
}
return true ;
}

//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
int StringToTimeFrame(string tf)
{
if(tf=="M1")
return PERIOD_M1 ;
else
if(tf=="M5")
return PERIOD_M5 ;
else
if(tf=="M15")
return PERIOD_M15 ;
else
if(tf=="M30")
return PERIOD_M30 ;
else
if(tf=="H1")
return PERIOD_H1 ;
else
if(tf=="H4")
return PERIOD_H4 ;
else
if(tf=="D1")
return PERIOD_D1 ;
else
if(tf=="W1")
return PERIOD_W1 ;
else
if(tf=="MN1")
return PERIOD_MN1 ;

return PERIOD_CURRENT ;
}

//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
void SetSettings(string symbol)
{
bool found=false ;
for(int i=0; i<ArraySize(inputsAct); i++)
{
if(inputsAct[i]._Currency==symbol)
{
_Currency=inputsAct[i]._Currency ;
_TimeFrame=StringToTimeFrame(inputsAct[i]._TimeFrame);
_Slowing = inputsAct[i]._Slowing;
_Whole_Number_Input = inputsAct[i]._Whole_Number_Input;
_Grid_Points = inputsAct[i]._Grid_Points;
_SL_Percentage = inputsAct[i]._SL_Percentage;
_RSI_Buy_Limit = inputsAct[i]._RSI_Buy_Limit;
_Sell_TP_in_Points = inputsAct[i]._Sell_TP_in_Points;
_Max_Days = inputsAct[i]._Max_Days;
_Stoc_Buy_Limit = inputsAct[i]._Stoc_Buy_Limit;
_Mom_Buy_Limit = inputsAct[i]._Mom_Buy_Limit;
_D_Period = inputsAct[i]._D_Period;
_Stoc_Sell_Limit = inputsAct[i]._Stoc_Sell_Limit;
_RSI_Sell_Limit = inputsAct[i]._RSI_Sell_Limit;
_Mom_Sell_Limit = inputsAct[i]._Mom_Sell_Limit;
_Buy_TP_in_Points = inputsAct[i]._Buy_TP_in_Points;
_Max_Open_Trades = inputsAct[i]._Max_Open_Trades;
_Lot_Percentage =inputsAct[i]._Lot_Percentage;
found=true ;
break ;
}
else
{
continue ;
}
}

if(!found)
{
_Currency=symbol;
_TimeFrame=PERIOD_CURRENT ; // Trading TimeFrame
_Slowing = 3; // Slowing
_Whole_Number_Input = 10; // Period
_Grid_Points = 200; // Grid Points
_SL_Percentage = 1; // SL Percentage
_RSI_Buy_Limit = 25; // RSI Buy Limit
_Sell_TP_in_Points = 300; // Sell TP in Points
_Max_Days = 14; // Max Days
_Stoc_Buy_Limit = 15; // Stoc Buy Limit
_Mom_Buy_Limit = 99.5; // Mom Buy Limit
_D_Period = 3; // D Period
_Stoc_Sell_Limit = 85; // Stoc Sell Limit
_RSI_Sell_Limit = 75; // RSI Sell Limit
_Mom_Sell_Limit = 100.5; // Mom Sell Limit
_Buy_TP_in_Points = 300; // Buy TP in Points
_Max_Open_Trades = 6; // Max Open Trades
_Lot_Percentage = 0.5; // Lot Percentage
}
}

//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
int GetGlobalOrders()
{
int cnt=0 ;
for(int i=0; i<OrdersTotal(); i++)
{
if(OrderSelect(i,SELECT_BY_POS) && OrderMagicNumber()==__STRATEGY_MAGIC+1)
cnt ++;
}
return cnt ;
}
//+------------------------------------------------------------------+

Comments

paul.krumme14163 · 3 years ago

I am working on Metatrader 4 and 5 since 5 years ago.

I have experience with Programming more than 10 years.

I have worked on similar projects to what you are looking for.

I will respect and implement your needs from day one.

I set the client priority always on top for my work

If you are not satisfied with my work, you may not pay for it.

I want $250 for this job.

my skype id: stephan_rothe79@outlook.com

Copyright © 2024 Spotware Systems Ltd. All rights reserved.
The services provided by Spotware Systems Ltd. are not available to citizens or residents of the USA. Neither is the information on our websites directed toward soliciting citizens or residents of the USA.