// ------------------------------------------------------------------------------------------------- // XMT-Scalper V3.0 // // // // // // ------------------------------------------------------------------------------------------------- #property copyright "" #property link "" //#property show_inputs #include //----------------------- Externals ---------------------------------------------------------------- // All inputals here have their name starting with a CAPITAL character input string Configuration = "==== Configuration ===="; input int Magic = -1; input string OrderCmt = ""; input bool ECN_Mode = FALSE; input bool Debug = FALSE; input bool Verbose = FALSE; input bool VirtualPendingOrders = true; input bool VirtualStops = true; input string TradingSettings = "==== Trade settings ===="; input double MaxSpread = 30.0; input int MaxExecution = 0; input int MaxExecutionMinutes = 5; input double TakeProfit = 10.0; input double StopLoss = 60.0; input double TrailingStart = 0; input double Commission = 0; input int Slippage = 3; input bool UseDynamicVolatilityLimit = TRUE; input double VolatilityMultiplier = 125; input double VolatilityLimit = 180; input bool UseVolatilityPercentage = TRUE; input double VolatilityPercentageLimit = 60; input bool UseMovingAverage = TRUE; input bool UseBollingerBands = TRUE; input double Deviation = 1.50; input int OrderExpireSeconds = 3600; input string Money_Management = "==== Money Management ===="; input bool MoneyManagement = TRUE; input double MinLots = 0.01; input double MaxLots = 100.0; input double Risk = 2.0; input double ManualLotsize = 0.1; input string Screen_Shooter = "==== Screen Shooter ===="; input bool TakeShots = FALSE; input int DelayTicks = 1; input int ShotsPerBar = 1; input string _tmp50_ = " --- Virtual Orders: graphic ---"; input ENUM_BASE_CORNER VOrdText_corner = CORNER_RIGHT_UPPER; input int VOrdText_x = 25; input int VOrdText_dx = 60; input int VOrdText_y = 20; input int VOrdText_dy = 14; input string VOrdText_font = "Arial"; input int VOrdText_font_size = 8; input color VOrdText_font_color = clrGold; //--------------------------- Globals -------------------------------------------------------------- // All globals have their name written in lower case characters string ea_version = "XMT-Scalper V3.0"; int indicatorperiod = 3; int brokerdigits = 0; int globalerror = 0; int lasttime = 0; int tickcounter = 0; int upto30counter = 0; int execution = -1; int avg_execution = 0; int execution_samples = 0; int starttime; int leverage; int lotbase; int err_busyserver; int err_lostconnection; int err_toomanyrequest; int err_invalidprice; int err_invalidstops; int err_invalidtradevolume; int err_pricechange; int err_brokerbuzy; int err_requotes; int err_toomanyrequests; int err_trademodifydenied; int err_tradecontextbuzy; double array_spread[30]; double lotsize; double highest; double lowest; double stoplevel; double stopout; double lotstep; double marginforonelot; int skipedticks=0; int ticks_samples=0; double avg_tickspermin=0; double vStopLoss; double vTakeProfit; double vManualLotsize; double vRisk; double vMinLots; double vMaxLots; double vVolatilityPercentageLimit; double vVolatilityLimit; double vVolatilityMultiplier; double vCommission; double vTrailingStart; int vMaxExecutionMinutes; int vMagic; #define VO_MAX 1000 int a_N = 0; int a_tickets[VO_MAX]; int a_type[VO_MAX]; string a_symbol[VO_MAX]; double a_volume[VO_MAX]; double a_open_price[VO_MAX]; double a_sl[VO_MAX]; double a_tp[VO_MAX]; int a_magic[VO_MAX]; string a_comment[VO_MAX]; color a_color[VO_MAX]; int vo_sel_ind; string vo_prefix; //======================= Program initialization =================================================== void OnInit() { string prefix = WindowExpertName() + "_"; vo_prefix = prefix + "vo_"; //----- if (IsTesting()) { a_N = 0; } else { if (a_N == 0) LoadStops(); } // Print short message at the start of initalization Print ("====== Initialization of ", ea_version, " ======"); // Reset time for execution control starttime = TimeLocal(); // Reset error variable globalerror = -1; // Get the broker decimals brokerdigits = Digits; // Get leverage leverage = AccountLeverage(); // Calculate stoplevel as max of either STOPLEVEL or FREEZELEVEL stoplevel = MathMax(MarketInfo(Symbol(), MODE_FREEZELEVEL), MarketInfo(Symbol(), MODE_STOPLEVEL)); // Get stoput level and re-calculate as fraction stopout = AccountStopoutLevel(); // Calculate lotstep lotstep = MarketInfo(Symbol(), MODE_LOTSTEP); vStopLoss = StopLoss; vTakeProfit = TakeProfit; vManualLotsize = ManualLotsize; vRisk = Risk; vMinLots = MinLots; vMaxLots = MaxLots; vVolatilityPercentageLimit = VolatilityPercentageLimit; vVolatilityLimit = VolatilityLimit; vVolatilityMultiplier = VolatilityMultiplier; vCommission = Commission; vTrailingStart = TrailingStart; vMaxExecutionMinutes = MaxExecutionMinutes; vMagic = Magic; // Adjust SL and TP to broker stoplevel if they are less than this stoplevel if (vStopLoss < stoplevel) vStopLoss = stoplevel; if (vTakeProfit < stoplevel) vTakeProfit = stoplevel; // Re-calculate variables vVolatilityPercentageLimit = vVolatilityPercentageLimit / 100.0 + 1.0; vVolatilityMultiplier = vVolatilityMultiplier / 10.0; ArrayInitialize(array_spread, 0); vVolatilityLimit = vVolatilityLimit * Point; vCommission = sub_normalizebrokerdigits(vCommission * Point); vTrailingStart = vTrailingStart * Point; stoplevel = stoplevel * Point; // If we have set MaxLot and/or MinLots to more/less than what the broker allows, then adjust it accordingly if (vMinLots < MarketInfo(Symbol(), MODE_MINLOT)) vMinLots = MarketInfo(Symbol(), MODE_MINLOT); if (vMaxLots > MarketInfo(Symbol(), MODE_MAXLOT)) vMaxLots = MarketInfo(Symbol(), MODE_MAXLOT); if (vMaxLots < vMinLots) vMaxLots = vMinLots; // Calculate margin required for 1 lot marginforonelot = MarketInfo(Symbol(), MODE_MARGINREQUIRED); // Amount of money in base currency for 1 lot lotbase = MarketInfo(Symbol(), MODE_LOTSIZE); // Also make sure that if the risk-percentage is too low or too high, that it's adjusted accordingly sub_recalculatewrongrisk(); // Calculate intitial lotsize lotsize = sub_calculatelotsize(); // If magic number is set to a value less than 0, then calculate MagicNumber automatically if (vMagic < 0) sub_magicnumber(); // If execution speed should be measured, then adjust maxexecution from minutes to seconds if (MaxExecution > 0) vMaxExecutionMinutes = MaxExecution * 60; // Print initial info sub_printdetails(); // Print short message at the end of initialization Print ("========== Initialization complete! ===========\n"); // Finally call the main trading subroutine OnTick(); } //======================= Program deinitialization ================================================= void OnDeinit(const int reason) { // Print summarize of broker errors sub_printsumofbrokererrors(); // Print short message when EA has been deinitialized Print (ea_version, " has been deinitialized!"); } //==================================== Program start =============================================== void OnTick() { //----- bool bDraw = true; if (IsTesting() && !IsVisualMode()) bDraw = false; if (IsOptimization()) bDraw = false; if (VirtualPendingOrders) { VO_CheckPendingOrders(); } VO_UpdatePOType(); if (VirtualStops) { VO_CheckStops(); VO_ClearStops(); } //----- // We must wait til we have enough of bar data before we call trading routine //Print("bars= ", iBars(Symbol(),PERIOD_M1)); if (iBars(Symbol(),PERIOD_M1) > indicatorperiod) sub_trade(); else Print ("Please wait until enough of bar data has been gathered!"); //----- if (VirtualPendingOrders || VirtualStops) { if (bDraw) { VO_DrawStops(); } } //----- } //================================ Subroutines starts here ========================================= // All subs have their names starting with sub_ // Exception are the standard routines init() and start() // // Notation: // All actual and formal parameters in subs have their names starting with par_ // All local variables in subs have thewir names starting with local_ // This is the main trading subroutine void sub_trade() { string local_textstring; string local_pair; bool local_wasordermodified; bool local_ordersenderror; bool local_isbidgreaterthanima; bool local_isbidgreaterthanibands; bool local_isbidgreaterthanindy; int local_orderticket; int local_orderexpiretime; //int local_lotstep; int local_loopcount2; int local_loopcount1; int local_pricedirection; int local_counter1; int local_counter2; //int local_paircounter; int local_askpart; int local_bidpart; double local_ask; double local_bid; double local_askplusdistance; double local_bidminusdistance; double local_volatilitypercentage; //double local_trailingdistance; double local_orderstoploss; double local_ordertakeprofit; double local_tpadjust; double local_ihigh; double local_ilow; double local_imalow; double local_imahigh; double local_imadiff; double local_ibandsupper; double local_ibandslower; double local_ibandsdiff; double local_volatility; double local_spread; double local_avgspread; double local_realavgspread; double local_fakeprice; double local_sumofspreads; double local_askpluscommission; double local_bidminuscommission; double local_skipticks; bool bRC; // Count tics if (lasttime < Time[0]) { // Consider only 10 samples at most. if (ticks_samples < 10) ticks_samples++; avg_tickspermin = avg_tickspermin + (tickcounter - avg_tickspermin) / ticks_samples; lasttime = Time[0]; tickcounter = 0; } else tickcounter++; // if testing and MaxExecution is set let's skip a proportional number of ticks them in order to // reproduce the effect of latency on this EA if (IsTesting() && MaxExecution!=0 && execution!=-1) { local_skipticks=MathRound(avg_tickspermin * MaxExecution/(60*1000)); if (skipedticks>=local_skipticks) { execution=-1; skipedticks=0; } else { skipedticks++; // Print("Skip tick " + skipticks); return; } } // Get Ask and Bid for the currency local_ask = MarketInfo(Symbol(), MODE_ASK); local_bid = MarketInfo(Symbol(), MODE_BID); // Calculate the channel of Volatility based on the difference of iHigh and iLow during current bar local_ihigh = iHigh(Symbol(), PERIOD_M1, 0); local_ilow = iLow(Symbol(), PERIOD_M1, 0); local_volatility = local_ihigh - local_ilow; // Calculate a channel on MovingAverage, and check if the price is outside of this channel local_imalow = iMA(Symbol(), PERIOD_M1, indicatorperiod, 0, MODE_LWMA, PRICE_LOW, 0); local_imahigh = iMA(Symbol(), PERIOD_M1, indicatorperiod, 0, MODE_LWMA, PRICE_HIGH, 0); local_imadiff = local_imahigh - local_imalow; local_isbidgreaterthanima = local_bid >= local_imalow + local_imadiff / 2.0; // Calculate a channel on BollingerBands, and check if the prcice is outside of this channel local_ibandsupper = iBands(Symbol(), PERIOD_M1, indicatorperiod, Deviation, 0, PRICE_OPEN, MODE_UPPER, 0); local_ibandslower = iBands(Symbol(), PERIOD_M1, indicatorperiod, Deviation, 0, PRICE_OPEN, MODE_LOWER, 0); local_ibandsdiff = local_ibandsupper - local_ibandslower; local_isbidgreaterthanibands = local_bid >= local_ibandslower + local_ibandsdiff / 2.0; // Calculate the highest and lowest values depending on which indicators to be used local_isbidgreaterthanindy = FALSE; if (UseMovingAverage == FALSE && UseBollingerBands == TRUE && local_isbidgreaterthanibands == TRUE) { local_isbidgreaterthanindy = TRUE; highest = local_ibandsupper; lowest = local_ibandslower; } else if (UseMovingAverage == TRUE && UseBollingerBands == FALSE && local_isbidgreaterthanima == TRUE) { local_isbidgreaterthanindy = TRUE; highest = local_imahigh; lowest = local_imalow; } else if (UseMovingAverage == TRUE && UseBollingerBands == TRUE && local_isbidgreaterthanima == TRUE && local_isbidgreaterthanibands == TRUE) { local_isbidgreaterthanindy = TRUE; highest = MathMax(local_ibandsupper, local_imahigh); lowest = MathMin(local_ibandslower, local_imalow); } // Calculate spread, adjuststoplevel, orderexpiretime and lotsize local_spread = local_ask - local_bid; local_orderexpiretime = TimeCurrent() + OrderExpireSeconds; local_orderexpiretime = TimeCurrent() + OrderExpireSeconds; lotsize = sub_calculatelotsize(); // Calculate average true spread, which is the average of the spread for the last 30 tics ArrayCopy(array_spread, array_spread, 0, 1, 29); array_spread[29] = local_spread; if (upto30counter < 30) upto30counter++; local_sumofspreads = 0; local_loopcount2 = 29; for (local_loopcount1 = 0; local_loopcount1 < upto30counter; local_loopcount1++) { local_sumofspreads += array_spread[local_loopcount2]; local_loopcount2--; } // Calculate an average of spreads based on the spread from the last 30 tics local_avgspread = local_sumofspreads / upto30counter; // Calculate price and spread considering commission local_askpluscommission = sub_normalizebrokerdigits(local_ask + vCommission); local_bidminuscommission = sub_normalizebrokerdigits(local_bid - vCommission); local_realavgspread = local_avgspread + vCommission; // Recalculate the VolatilityLimit if it's set to dynamic. It's based on the average of spreads + commission if (UseDynamicVolatilityLimit == TRUE) vVolatilityLimit = local_realavgspread * vVolatilityMultiplier; // Reset pricedirection to for no indication of trading direction local_pricedirection = 0; // // If the variables below have values it means that we have enough of data from broker server if (local_volatility && vVolatilityLimit && lowest && highest) { // The Volatility is outside of the VolatilityLimit, so we can now open a trade if (local_volatility > vVolatilityLimit) { // Calculate how much it differs local_volatilitypercentage = local_volatility / vVolatilityLimit; // In case of UseVolatilityPercentage == TRUE then also check if it differ enough of percentage if ((UseVolatilityPercentage == FALSE) || (UseVolatilityPercentage == TRUE && local_volatilitypercentage > vVolatilityPercentageLimit)) { if (local_bid < lowest) local_pricedirection = -1; // BUY or BUYSTOP else if (local_bid > highest) local_pricedirection = 1; // SELL or SELLSTOP } } else local_volatilitypercentage = 0; } // Out of money if (AccountBalance() <= 0.0) { Comment("ERROR -- Account Balance is " + DoubleToStr(MathRound(AccountBalance()), 0)); return; } // Reset execution time execution = -1; // Reset counters local_counter1 = 0; local_counter2 = 0; // Loop through all open orders (if any) to either modify them or delete them for (local_loopcount2 = 0; local_loopcount2 < OrdersTotalEx(); local_loopcount2++) { bRC = OrderSelectEx(local_loopcount2, SELECT_BY_POS, MODE_TRADES); // We've found an that matches the magic number and is open if (OrderMagicNumberEx() == vMagic /*&& OrderCloseTime() == 0*/) { // If the order doesn't match the currency pair from the chart then check next open order if (OrderSymbolEx() != Symbol()) { local_counter2++; continue; } // Select order by type of order switch (OrderTypeEx()) { // We've found a matching BUY-order case OP_BUY: // Start endless loop while (true) { local_orderstoploss = OrderStopLossEx(); local_ordertakeprofit = OrderTakeProfitEx(); // Ok to modify the order if its TP is less than the price+commission+stoplevel AND price+SL-TP is greater than trailingStart if (local_ordertakeprofit < sub_normalizebrokerdigits(local_askpluscommission + stoplevel) && local_askpluscommission + stoplevel - local_ordertakeprofit > vTrailingStart) { local_orderstoploss = sub_normalizebrokerdigits(local_bid - stoplevel); local_ordertakeprofit = sub_normalizebrokerdigits(local_askpluscommission + stoplevel); execution = GetTickCount(); local_wasordermodified = OrderModifyEx(OrderTicketEx(), 0, local_orderstoploss, local_ordertakeprofit, local_orderexpiretime, Lime); // Order was modified with new SL and TP if (local_wasordermodified > 0) { // Calculate execution speed execution = GetTickCount() - execution; // If we have choosen to take snapshots and we're not backtesting, then do so if (TakeShots && !IsTesting()) sub_takesnapshot(); } // Order was not modified else { // Reset execution counter execution = -1; // Add to errors sub_errormessages(); } } // Break out from endless loop break; } // count 1 more up local_counter1++; // Break out from switch break; // We've found a matching SELL-order case OP_SELL: // Start endless loop while (true) { local_orderstoploss = OrderStopLossEx(); local_ordertakeprofit = OrderTakeProfitEx(); // Ok to modify the order if its TP is greater than price-commission-SL AND TP-price-commission+stoplevel is greater than trailingstart if (local_ordertakeprofit > sub_normalizebrokerdigits(local_bidminuscommission - stoplevel) && local_ordertakeprofit - local_bidminuscommission + stoplevel > vTrailingStart) { local_orderstoploss = sub_normalizebrokerdigits(local_ask + stoplevel); local_ordertakeprofit = sub_normalizebrokerdigits(local_bidminuscommission - stoplevel); execution = GetTickCount(); local_wasordermodified = OrderModifyEx(OrderTicketEx(), 0, local_orderstoploss, local_ordertakeprofit, local_orderexpiretime, Orange); // Order was modiified with new SL and TP if (local_wasordermodified > 0) { // Calculate execution speed execution = GetTickCount() - execution; // If we have choosen to take snapshots and we're not backtesting, then do so if (TakeShots && !IsTesting()) sub_takesnapshot(); } // Order was not modified else { // Reset execution counter execution = -1; // Add to errors sub_errormessages(); } } // Break out from endless loop break; } // count 1 more up local_counter1++; // Break out from switch break; // We've found a matching BUYSTOP-order case OP_BUYSTOP: // Price must NOT be larger than indicator in order to modify the order, otherwise the order will be deleted if (local_isbidgreaterthanindy == FALSE) { // Beside stoplevel, this is how much the SL and TP are changed local_tpadjust = OrderTakeProfitEx() - OrderOpenPriceEx() - vCommission; // Start endless loop while (true) { // Ok to modify the order if price+stoplevel is less than orderprice AND orderprice-price-stoplevel is greater than trailingstart if (sub_normalizebrokerdigits(local_ask + stoplevel) < OrderOpenPriceEx() && OrderOpenPriceEx() - local_ask - stoplevel > vTrailingStart) { execution = GetTickCount(); local_wasordermodified = OrderModifyEx(OrderTicketEx(), sub_normalizebrokerdigits(local_ask + stoplevel), sub_normalizebrokerdigits(local_bid + stoplevel - local_tpadjust), sub_normalizebrokerdigits(local_askpluscommission + stoplevel + local_tpadjust), 0, Lime); // Order was modified if (local_wasordermodified > 0) { // Calculate execution speed execution = GetTickCount() - execution; if (Debug || Verbose) Print ("Order executed in " + execution + " ms"); } // Order was not modified else { // Reset execution counter execution = -1; // Add to errors sub_errormessages(); } } // Break out from endless loop break; } // count 1 more up local_counter1++; } // Price was larger than the indicator, so delete the order else bRC = OrderDeleteEx(OrderTicketEx()); // Break out from switch break; // We've found a matching SELLSTOP-order case OP_SELLSTOP: // Price must be larger than the indicator in order to modify the order, otherwise the order will be deleted if (local_isbidgreaterthanindy == TRUE) { // Beside stoplevel, this is how much the SL and TP are changed local_tpadjust = OrderOpenPriceEx() - OrderTakeProfitEx() - vCommission; // Endless loop while (true) { // Ok to modify order if price-stoplevel is greater than orderprice AND price-stoplevel-orderprice is greater than trailingstart if (sub_normalizebrokerdigits(local_bid - stoplevel) > OrderOpenPriceEx() && local_bid - stoplevel - OrderOpenPriceEx() > vTrailingStart) { execution = GetTickCount(); local_wasordermodified = OrderModifyEx(OrderTicketEx(), sub_normalizebrokerdigits(local_bid - stoplevel), sub_normalizebrokerdigits(local_ask - stoplevel + local_tpadjust), sub_normalizebrokerdigits(local_bidminuscommission - stoplevel - local_tpadjust), 0, Orange); // Order was modified if (local_wasordermodified > 0) { // Calculate execution speed execution = GetTickCount() - execution; if (Debug || Verbose) Print ("Order executed in " + execution + " ms"); } // Order was not modified else { // Reset execution counter execution = -1; // Add to errors sub_errormessages(); } } // Break out from endless loop break; } // count 1 more up local_counter1++; } // Price was NOT larger than the indicator, so delete the order else bRC = OrderDeleteEx(OrderTicketEx()); } // end of switch } // end if OrderMagicNumber } // end for loopcount2 - end of loop through open orders // Calculate and keep track on global error number if (globalerror >= 0 || globalerror == -2) { local_bidpart = NormalizeDouble(local_bid / Point, 0); local_askpart = NormalizeDouble(local_ask / Point, 0); if (local_bidpart % 10 != 0 || local_askpart % 10 != 0) globalerror = -1; else { if (globalerror >= 0 && globalerror < 10) globalerror++; else globalerror = -2; } } // Reset error-variable local_ordersenderror = FALSE; // Before executing new orders, lets check the average execution time. if (local_pricedirection != 0 && MaxExecution > 0 && avg_execution > MaxExecution) { local_pricedirection = 0; // Ignore the order opening triger if (Debug || Verbose) Print("Server is too Slow. Average Execution: " + avg_execution); } // If we have no open orders AND a price breakout AND average spread is less or equal to max allowed spread AND we have no errors THEN proceed if (local_counter1 == 0 && local_pricedirection != 0 && sub_normalizebrokerdigits(local_realavgspread) <= sub_normalizebrokerdigits(MaxSpread * Point) && globalerror == -1) { // If we have a price breakout downwards (Bearish) then send a SELLSTOP order if (local_pricedirection < 0) // Send a BUYSTOP { execution = GetTickCount(); local_askplusdistance = local_ask + stoplevel; // SL and TP is not sent with order, but added afterwords in a OrderModify command if (ECN_Mode == TRUE) { // Send BUYSTOP order without SL and TP local_orderticket = OrderSendEx(Symbol(), OP_BUYSTOP, lotsize, local_askplusdistance, Slippage, 0, 0, OrderCmt, vMagic, 0, Lime); // OrderSend was executed successfully if (local_orderticket > 0) { // Calculate execution speed execution = GetTickCount() - execution; if (Debug || Verbose) Print ("Order executed in " + execution + " ms"); PlaySound("news.wav"); Print("BUYSTOP: " + sub_dbl2strbrokerdigits(local_ask + stoplevel) + " SL: " + sub_dbl2strbrokerdigits(local_bid + stoplevel) + " TP: " + sub_dbl2strbrokerdigits(local_askpluscommission + stoplevel)); // If we have choosen to take snapshots and we're not backtesting, then do so if (TakeShots && !IsTesting()) sub_takesnapshot(); } // end if ordersend // OrderSend was NOT executed else { local_ordersenderror = TRUE; Print("ERROR OrderSend BUYSTOP : " + sub_dbl2strbrokerdigits(local_ask + stoplevel) + " SL:" + sub_dbl2strbrokerdigits(local_bid + stoplevel) + " TP:" + sub_dbl2strbrokerdigits(local_askpluscommission + stoplevel)); execution = -1; // Add to errors sub_errormessages(); } // OrderSend was executed successfully, so now modify it with SDL and TP if (OrderSelectEx(local_orderticket, SELECT_BY_TICKET)) { local_wasordermodified = OrderModifyEx(OrderTicketEx(), OrderOpenPriceEx(), local_askplusdistance - vStopLoss * Point, local_askplusdistance + vTakeProfit * Point, local_orderexpiretime, Lime); // OrderModify was executed successfully if (local_wasordermodified > 0) { // Calculate execution speed execution = GetTickCount() - execution; if (Debug || Verbose) Print ("Order executed in " + execution + " ms"); PlaySound("news.wav"); Print("BUYSTOP: " + sub_dbl2strbrokerdigits(local_ask + stoplevel) + " SL: " + sub_dbl2strbrokerdigits(local_bid + stoplevel) + " TP: " + sub_dbl2strbrokerdigits(local_askpluscommission + stoplevel)); // If we have choosen to take snapshots and we're not backtesting, then do so if (TakeShots && !IsTesting()) sub_takesnapshot(); } // end successful ordermodiify // Order was NOT modified else { local_ordersenderror = TRUE; Print("ERROR OrderModify BUYSTOP: " + sub_dbl2strbrokerdigits(local_ask + stoplevel) + " SL: " + sub_dbl2strbrokerdigits(local_bid + stoplevel) + " TP: " + sub_dbl2strbrokerdigits(local_askpluscommission + stoplevel)); execution = -1; // Add to errors sub_errormessages(); } // end if-else } // end if ordermodify } // end if ECN_Mode // No ECN-mode, SL and TP can be sent directly else { // Send BUYSTOP order with SL and TP /* Print( "vStopLoss= ", vStopLoss, ", vTakeProfit= ", vTakeProfit, ", Ask= ", DoubleToStr(Ask, Digits), ", local_askplusdistance= ", DoubleToStr(local_askplusdistance, Digits), ", sl= ", DoubleToStr(local_askplusdistance - vStopLoss * Point, Digits), ", tp= ", DoubleToStr(local_askplusdistance + vTakeProfit * Point, Digits), ", point= ", DoubleToStr(Point(), Digits)); */ local_orderticket = OrderSendEx(Symbol(), OP_BUYSTOP, lotsize, local_askplusdistance, Slippage, local_askplusdistance - vStopLoss * Point, local_askplusdistance + vTakeProfit * Point, OrderCmt, vMagic, local_orderexpiretime, Lime); if (local_orderticket > 0) // OrderSend was executed suxxessfully { // Calculate execution speed execution = GetTickCount() - execution; if (Debug || Verbose) Print ("Order executed in " + execution + " ms"); PlaySound("news.wav"); Print("BUYSTOP: " + sub_dbl2strbrokerdigits(local_ask + stoplevel) + " SL: " + sub_dbl2strbrokerdigits(local_bid + stoplevel) + " TP: " + sub_dbl2strbrokerdigits(local_askpluscommission + stoplevel)); // If we have choosen to take snapshots and we're not backtesting, then do so if (TakeShots && !IsTesting()) sub_takesnapshot(); } // end successful ordersend // Order was NOT sent else { local_ordersenderror = TRUE; Print("ERROR BUYSTOP : " + sub_dbl2strbrokerdigits(local_ask + stoplevel) + " SL:" + sub_dbl2strbrokerdigits(local_bid + stoplevel) + " TP:" + sub_dbl2strbrokerdigits(local_askpluscommission + stoplevel)); execution = -1; // Add to errors sub_errormessages(); } // end if-else } // end no ECN-mode } // end local_pricedirection < 0 // If we have a price breakout upwards (Bullish) then send a SELLSTOP order else if (local_pricedirection > 0) { local_bidminusdistance = local_bid - stoplevel; execution = GetTickCount(); // SL and TP cannot be sent with order, but must be sent afterwords in a modify command if (ECN_Mode) { // Send SELLSTOP without SL and TP local_orderticket = OrderSendEx(Symbol(), OP_SELLSTOP, lotsize, local_bidminusdistance, Slippage, 0, 0, OrderCmt, vMagic, 0, Orange); if (OrderSelectEx(local_orderticket, SELECT_BY_TICKET)) local_wasordermodified = OrderModifyEx(OrderTicketEx(), OrderOpenPriceEx(), local_bidminusdistance + vStopLoss * Point, local_bidminusdistance - vTakeProfit * Point, local_orderexpiretime, Orange); // OrderModify was executed successfully if (local_wasordermodified > 0) { // Calculate execution speed execution = GetTickCount() - execution; if (Debug || Verbose) Print ("Order executed in " + execution + " ms"); PlaySound("news.wav"); Print("SELLSTOP: " + sub_dbl2strbrokerdigits(local_bid - stoplevel) + " SL: " + sub_dbl2strbrokerdigits(local_ask - stoplevel) + " TP: " + sub_dbl2strbrokerdigits(local_bidminuscommission - stoplevel)); // If we have choosen to take snapshots and we're not backtesting, then do so if (TakeShots && !IsTesting()) sub_takesnapshot(); } // end if ordermodify was executed successfully // Order was NOT executed else { local_ordersenderror = TRUE; Print("SELLSTOP : " + sub_dbl2strbrokerdigits(local_bid - stoplevel) + " SL: " + sub_dbl2strbrokerdigits(local_ask - stoplevel) + " TP: " + sub_dbl2strbrokerdigits(local_bidminuscommission - stoplevel)); execution = -1; // Add to errors sub_errormessages(); } } else // No ECN-mode, SL and TP can be sent directly { // Send SELLSTOP order local_orderticket = OrderSendEx(Symbol(), OP_SELLSTOP, lotsize, local_bidminusdistance, Slippage, local_bidminusdistance + vStopLoss * Point, local_bidminusdistance - vTakeProfit * Point, OrderCmt, vMagic, local_orderexpiretime, Orange); // OrderSend was executed successfully if (local_orderticket > 0) { execution = GetTickCount() - execution; if (Debug || Verbose) Print ("Order executed in " + execution + " ms"); if (TakeShots && !IsTesting()) sub_takesnapshot(); PlaySound("news.wav"); Print("SELLSTOP : " + sub_dbl2strbrokerdigits(local_bid - stoplevel) + " SL: " + sub_dbl2strbrokerdigits(local_ask - stoplevel) + " TP: " + sub_dbl2strbrokerdigits(local_bidminuscommission - stoplevel)); } // end successful ordersend // OrderSend was executed successfully else { local_ordersenderror = TRUE; Print("ERROR SELLSTOP: " + sub_dbl2strbrokerdigits(local_bid - stoplevel) + " SL: " + sub_dbl2strbrokerdigits(local_ask - stoplevel) + " TP: " + sub_dbl2strbrokerdigits(local_bidminuscommission - stoplevel)); execution = -1; // Add to errors sub_errormessages(); } // end if-else } // end no ECN-mode } // end local_pricedirection > 0 } // end if execute new orders // If we have no samples, every MaxExecutionMinutes a new OrderModify execution test is done if (MaxExecution && execution == -1 && (TimeLocal() - starttime) % vMaxExecutionMinutes == 0) { // When backtesting, simulate random execution time based on the setting if (IsTesting() && MaxExecution) { MathSrand(TimeLocal()); execution = MathRand() / (32767 / MaxExecution); } else { // Unless backtesting, lets send a fake order to check the OrderModify execution time, if (!IsTesting()) { // To be sure that the fake order never is executed, st the price to twice the current price local_fakeprice = local_ask * 2.0; // Send a BUYSTOP order local_orderticket = OrderSendEx(Symbol(), OP_BUYSTOP, lotsize, local_fakeprice, Slippage, 0, 0, OrderCmt, vMagic, 0, Lime); execution = GetTickCount(); // Send a modify command where we adjust the price with +1 pip local_wasordermodified = OrderModifyEx(local_orderticket, local_fakeprice + 10 * Point, 0, 0, 0, Lime); // Calculate execution speed execution = GetTickCount() - execution; // Delete the order bRC = OrderDeleteEx(local_orderticket); } } } // Do we have a valid execution sample? Update the average execution time. if (execution >= 0) { // Consider only 10 samples at most. if (execution_samples < 10) execution_samples++; // Calculate average execution speed avg_execution = avg_execution + (execution - avg_execution) / execution_samples; } // Check initialization if (globalerror >= 0) Comment("Robot is initializing..."); else { // Error if (globalerror == -2) Comment("ERROR -- Instrument " + Symbol() + " prices should have " + brokerdigits + " fraction digits on broker account"); // No errors, ready to print else { local_textstring = TimeToStr(TimeCurrent()) + " Tick: " + sub_adjust00instring(tickcounter) + " Ticks/min:" + avg_tickspermin; // Only show / print this if Debug OR Verbose are set to TRUE if (Debug || Verbose) { local_textstring = local_textstring + "\n*** DEBUG MODE *** \nCurrency pair: " + Symbol() + ", Volatility: " + sub_dbl2strbrokerdigits(local_volatility) + ", vVolatilityLimit: " + sub_dbl2strbrokerdigits(vVolatilityLimit) + ", VolatilityPercentage: " + sub_dbl2strbrokerdigits(local_volatilitypercentage); local_textstring = local_textstring + "\nPriceDirection: " + StringSubstr("BUY NULLSELL", 4 * local_pricedirection + 4, 4) + ", ImaHigh: " + sub_dbl2strbrokerdigits(local_imahigh) + ", ImaLow: " + sub_dbl2strbrokerdigits(local_imalow) + ", BBandUpper: " + sub_dbl2strbrokerdigits(local_ibandsupper); local_textstring = local_textstring + ", BBandLower: " + sub_dbl2strbrokerdigits(local_ibandslower) + ", Expire: " + TimeToStr(local_orderexpiretime, TIME_MINUTES) + ", NumOrders: " + local_counter1; local_textstring = local_textstring + "\nTrailingLimit: " + sub_dbl2strbrokerdigits(stoplevel) + ", Stoplevel: " + sub_dbl2strbrokerdigits(stoplevel) + "; TrailingStart: " + sub_dbl2strbrokerdigits(vTrailingStart); } local_textstring = local_textstring + "\nBid: " + sub_dbl2strbrokerdigits(local_bid) + ", ASK: " + sub_dbl2strbrokerdigits(local_ask) + ", AvgSpread: " + sub_dbl2strbrokerdigits(local_avgspread) + ", Commission: " + sub_dbl2strbrokerdigits(vCommission) + ", RealAvgSpread: " + sub_dbl2strbrokerdigits(local_realavgspread) + ", Lots: " + DoubleToStr(lotsize, 5) + ", MinLots: " + DoubleToStr(vMinLots,5) + ", Execution: " + execution + " ms"; if (sub_normalizebrokerdigits(local_realavgspread) > sub_normalizebrokerdigits(MaxSpread * Point)) { local_textstring = local_textstring + "\n" + "The current spread (" + sub_dbl2strbrokerdigits(local_realavgspread) +") is higher than what has been set as MaxSpread (" + sub_dbl2strbrokerdigits(MaxSpread * Point) + ") so no trading is allowed right now on this currency pair!"; } if (MaxExecution > 0 && avg_execution > MaxExecution) { local_textstring = local_textstring + "\n" + "The current Avg Execution (" + avg_execution +") is higher than what has been set as MaxExecution (" + MaxExecution+ " ms), so no trading is allowed right now on this currency pair!"; } Comment(local_textstring); // Only print this if we have a any orders OR have a price breakout OR Verbode mode is set to TRUE if (local_counter1 != 0 || local_pricedirection != 0 || Verbose) sub_printformattedstring(local_textstring); } // end if-else } // end check initialization } // end sub // Convert a decimal number to a text string string sub_dbl2strbrokerdigits(double par_a) { return (DoubleToStr(par_a, brokerdigits)); } // Adjust numbers with as many decimals as the broker uses double sub_normalizebrokerdigits(double par_a) { return (NormalizeDouble(par_a, brokerdigits)); } // Adjust textstring with zeros at the end string sub_adjust00instring(int par_a) { if (par_a < 10) return ("00" + par_a); if (par_a < 100) return ("0" + par_a); return ("" + par_a); } // Print out formatted textstring void sub_printformattedstring(string par_a) { int local_difference; int local_a = -1; while (local_a < StringLen(par_a)) { local_difference = local_a + 1; local_a = StringFind(par_a, "\n", local_difference); if (local_a == -1) { Print(StringSubstr(par_a, local_difference)); return; } Print(StringSubstr(par_a, local_difference, local_a - local_difference)); } } // Magic Number - calculated from a sum of account number and ASCII-codes from currency pair void sub_magicnumber() { string local_currpair = Symbol(); int local_length = StringLen (local_currpair); int local_asciisum = 0; int local_counter; for (local_counter = 0; local_counter < local_length -1; local_counter++) local_asciisum += StringGetChar (local_currpair, local_counter); vMagic = AccountNumber() + local_asciisum; } // Main routine for making a screenshoot / printscreen void sub_takesnapshot() { static datetime local_lastbar; static int local_doshot = -1; static int local_oldphase = 3000000; int local_shotinterval; int local_phase; if (ShotsPerBar > 0) local_shotinterval = MathRound((60 * Period()) / ShotsPerBar); else local_shotinterval = 60 * Period(); local_phase = MathFloor((CurTime() - Time[0]) / local_shotinterval); if (Time[0] != local_lastbar) { local_lastbar = Time[0]; local_doshot = DelayTicks; } else if (local_phase > local_oldphase) sub_makescreenshot("i"); local_oldphase = local_phase; if(local_doshot == 0) sub_makescreenshot(""); if(local_doshot >= 0) local_doshot -= 1; return; } // add leading zeros that the resulting string has 'digits' length. string sub_maketimestring(int par_number, int par_digits) { string local_result; local_result = DoubleToStr(par_number, 0); while (StringLen(local_result) < par_digits) local_result = "0" + local_result; return (local_result); } // Make a screenshoot / printscreen void sub_makescreenshot(string par_sx = "") { static int local_no = 0; local_no++; string fn = "SnapShot"+Symbol()+Period()+"\\"+Year()+"-"+sub_maketimestring(Month(),2)+"-"+sub_maketimestring(Day(),2)+" "+sub_maketimestring(Hour(),2)+"_"+sub_maketimestring(Minute(),2)+"_"+sub_maketimestring(Seconds( ),2)+" "+local_no+par_sx+".gif"; if (!ScreenShot(fn,640,480)) Print("ScreenShot error: ", ErrorDescription(GetLastError())); } // Calculate lotsize based on Equity, Risk (in %) and vStopLoss in points double sub_calculatelotsize() { string local_textstring; double local_availablemoney; double local_lotsize; double local_maxlot; double local_minlot; // Get available money as Equity local_availablemoney = AccountEquity(); // Maximum allowed Lot by the broker according to Equity. And we don't use 100% but 98% local_maxlot = MathFloor(local_availablemoney * 0.98 / marginforonelot / lotstep) * lotstep; // Minimum allowed Lot by the broker local_minlot = vMinLots; // Lot according to Risk. Dont use 100% but 98% (= 102) to avoid local_lotsize = MathFloor(vRisk / 102 * local_availablemoney / vStopLoss / lotstep) * lotstep; // Empty textstring local_textstring = ""; // Use manual fix lotsize, but if necessary adjust to within limits if (MoneyManagement == FALSE) { // Set lotsize to manual lotsize local_lotsize = vManualLotsize; // Check if vManualLotsize is greater than allowed lotsize if (vManualLotsize > local_maxlot) { local_lotsize = local_maxlot; local_textstring = "Note: Manual lotsize is too high. It has been recalculated to maximum allowed " + DoubleToStr(local_maxlot,2); Print (local_textstring); Comment (local_textstring); vManualLotsize = local_maxlot; } else if (vManualLotsize < local_minlot) local_lotsize = local_minlot; } return (local_lotsize); } // Re-calculate a new Risk if the current one is too low or too high void sub_recalculatewrongrisk() { string local_textstring; double local_availablemoney; double local_maxlot; double local_minlot; //double local_lotsize; double local_maxrisk; double local_minrisk; // Get available amount of money as Equity local_availablemoney = AccountEquity(); // Maximum allowed Lot by the broker according to Equity local_maxlot = MathFloor(local_availablemoney / marginforonelot / lotstep) * lotstep; // Maximum allowed Risk by the broker according to maximul allowed Lot and Equity local_maxrisk = MathFloor(local_maxlot * vStopLoss / local_availablemoney * 100 / 0.1) * 0.1; // Minimum allowed Lot by the broker local_minlot = vMinLots; // Minimum allowed Risk by the broker according to minlots_broker local_minrisk = MathRound(local_minlot * vStopLoss / local_availablemoney * 100 / 0.1) * 0.1; // Empty textstring local_textstring = ""; if (MoneyManagement == TRUE) { // If Risk% is greater than the maximum risklevel the broker accept, then adjust Risk accordingly and print out changes if (vRisk > local_maxrisk) { local_textstring = local_textstring + "Note: Risk has manually been set to " + DoubleToStr(vRisk,1) + " but cannot be higher than " + DoubleToStr(local_maxrisk,1) + " according to "; local_textstring = local_textstring + "the broker, vStopLoss and Equity. It has now been adjusted accordingly to " + DoubleToStr(local_maxrisk,1) + "%"; vRisk = local_maxrisk; sub_printandcomment(local_textstring); } // If Risk% is less than the minimum risklevel the broker accept, then adjust Risk accordingly and print out changes if (vRisk < local_minrisk) { local_textstring = local_textstring + "Note: Risk has manually been set to " + DoubleToStr(vRisk,1) + " but cannot be lower than " + DoubleToStr(local_minrisk,1) + " according to "; local_textstring = local_textstring + "the broker, vStopLoss and Equity. It has now been adjusted accordingly to " + DoubleToStr(local_minrisk,1) + "%"; vRisk = local_minrisk; sub_printandcomment(local_textstring); } } // Don't use MoneyManagement, use fixed manual lotsize else // MoneyManagement == FALSE { // Check and if necessary adjust manual lotsize to inputal limits if (vManualLotsize < vMinLots) { local_textstring = "Manual lotsize " + DoubleToStr(vManualLotsize,2) + " cannot be less than " + DoubleToStr(vMinLots,2) + ". It has now been adjusted to " + DoubleToStr(vMinLots,2); vManualLotsize = vMinLots; sub_printandcomment(local_textstring); } if (vManualLotsize > vMaxLots) { local_textstring = "Manual lotsize " + DoubleToStr(vManualLotsize,2) + " cannot be greater than " + DoubleToStr(vMaxLots,2) + ". It has now been adjusted to " + DoubleToStr(vMinLots,2); vManualLotsize = vMaxLots; sub_printandcomment(local_textstring); } // Check to see that manual lotsize does not exceeds maximum allowed lotsize if (vManualLotsize > local_maxlot) { local_textstring = "Manual lotsize " + DoubleToStr(vManualLotsize,2) + " cannot be greater than maximum allowed lotsize. It has now been adjusted to " + DoubleToStr(local_maxlot,2); vManualLotsize = local_maxlot; sub_printandcomment(local_textstring); } } } // Print out broker details and other info void sub_printdetails() { string local_margintext; string local_stopouttext; string local_fixedlots; int local_type; int local_freemarginmode; int local_stopoutmode; local_type = IsDemo() + IsTesting(); local_freemarginmode = AccountFreeMarginMode(); local_stopoutmode = AccountStopoutMode(); if (local_freemarginmode == 0) local_margintext = "that floating profit/loss is not used for calculation."; else if (local_freemarginmode == 1) local_margintext = "both floating profit and loss on open positions."; else if (local_freemarginmode == 2) local_margintext = "only profitable values, where current loss on open positions are not included."; else if (local_freemarginmode == 3) local_margintext = "only loss values are used for calculation, where current profitable open positions are not included."; if (local_stopoutmode == 0) local_stopouttext = "percentage ratio between margin and equity."; else if (local_stopoutmode == 1) local_stopouttext = "comparison of the free margin level to the absolute value."; if (MoneyManagement == TRUE) local_fixedlots = " (automatically calculated lots)."; if (MoneyManagement == FALSE) local_fixedlots = " (fixed manual lots)."; Print ("Broker name: ", AccountCompany()); Print ("Broker server: ", AccountServer()); Print ("Account type: ", StringSubstr("RealDemoTest", 4 * local_type, 4)); Print ("Initial account balance: ", AccountBalance()," ", AccountCurrency()); Print ("Broker digits: ", brokerdigits); Print ("Broker stoplevel / freezelevel (max): ", stoplevel / Point," pip (= ", DoubleToStr(stoplevel,5),")"); Print ("Broker stopout level: ", stopout,"%"); Print ("Broker Point: ", DoubleToStr (Point, brokerdigits)," on ", AccountCurrency()); Print ("Broker account leverage in percentage: ", leverage); Print ("Broker credit value on the account: ", AccountCredit()); Print ("Broker account margin: ", AccountMargin()); Print ("Broker calculation of free margin allowed to open positions considers " + local_margintext); Print ("Broker calculates stopout level as " + local_stopouttext); Print ("Broker requires at least ", marginforonelot," ", AccountCurrency()," in margin for 1 lot."); Print ("Broker set 1 lot to trade ", lotbase," ", AccountCurrency()); Print ("Broker minimum allowed lotsize: ", vMinLots); Print ("Broker maximum allowed lotsize: ", vMaxLots); Print ("Broker allow lots to be resized in ", lotstep, " steps."); Print ("Risk: ", vRisk,"%"); Print ("Risk adjusted lotsize: ", DoubleToStr(lotsize,2) + local_fixedlots); } // Print and show comment of text void sub_printandcomment(string par_text) { Print (par_text); Comment (par_text); } // Summarize error messages that comes from the broker server void sub_errormessages() { switch (GetLastError()) { // Trade server is busy case 4: // ERR_SERVER_BUSY: err_busyserver++; case 6: // ERR_NO_CONNECTION: err_lostconnection++; case 8: // ERR_TOO_FREQUENT_REQUESTS: err_toomanyrequest++; case 129: // ERR_INVALID_PRICE: err_invalidprice++; case 130: // ERR_INVALID_STOPS: err_invalidstops++; case 131: // ERR_INVALID_TRADE_VOLUME: err_invalidtradevolume++; case 135: // ERR_PRICE_CHANGED: err_pricechange++; case 137: // ERR_BROKER_BUSY: err_brokerbuzy++; case 138: // ERR_REQUOTE: err_requotes++; case 141: // ERR_TOO_MANY_REQUESTS: err_toomanyrequests++; case 145: // ERR_TRADE_MODIFY_DENIED: err_trademodifydenied++; case 146: // ERR_TRADE_CONTEXT_BUSY: err_tradecontextbuzy++; } } // Print out and comment summarized messages from the broker void sub_printsumofbrokererrors() { string local_txt; local_txt = "Number of times the brokers server reported that "; if (err_busyserver > 0) sub_printandcomment(local_txt + "it is buzy: " + DoubleToStr(err_busyserver,0)); if (err_lostconnection > 0) sub_printandcomment(local_txt + "the connection is lost: " + DoubleToStr(err_lostconnection,0)); if (err_toomanyrequest > 0) sub_printandcomment(local_txt + "there was too many requests: " + DoubleToStr(err_toomanyrequest,0)); if (err_invalidprice > 0) sub_printandcomment(local_txt + "the price was invalid: " + DoubleToStr(err_invalidprice,0)); if (err_invalidstops > 0) sub_printandcomment(local_txt + "invalid SL and/or TP: " + DoubleToStr(err_invalidstops,0)); if (err_invalidtradevolume > 0) sub_printandcomment(local_txt + "invalid lot size: " + DoubleToStr(err_invalidtradevolume,0)); if (err_pricechange > 0) sub_printandcomment(local_txt + "the price has changed: " + DoubleToStr(err_pricechange,0)); if (err_brokerbuzy > 0) sub_printandcomment(local_txt + "the broker is buzy: " + DoubleToStr(err_brokerbuzy,0)); if (err_requotes > 0) sub_printandcomment(local_txt + "requotes " + DoubleToStr(err_requotes,0)); if (err_toomanyrequests > 0) sub_printandcomment(local_txt + "too many requests " + DoubleToStr(err_toomanyrequests,0)); if (err_trademodifydenied > 0) sub_printandcomment(local_txt + "modifying orders is denied " + DoubleToStr(err_trademodifydenied,0)); if (err_tradecontextbuzy > 0) sub_printandcomment(local_txt + "trade context is buzy: " + DoubleToStr(err_tradecontextbuzy,0)); } //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ int GetSAInd(int ticket) { int size = a_N; for (int i=0; i= 0); } } return (false); } bool OrderDeleteEx(int ticket) { if (!VirtualPendingOrders && !VirtualStops) { return (OrderDelete(ticket)); } int ind = GetSAInd(ticket); if (ind >= 0) { VOrderRemove(ind); } return (true); } int OrderTicketEx() { if (!VirtualPendingOrders && !VirtualStops) { return (OrderTicket()); } return (a_tickets[vo_sel_ind]); } int OrderTypeEx() { if (!VirtualPendingOrders && !VirtualStops) { return (OrderType()); } return (a_type[vo_sel_ind]); } string OrderSymbolEx() { if (!VirtualPendingOrders && !VirtualStops) { return (OrderSymbol()); } return (a_symbol[vo_sel_ind]); } double OrderOpenPriceEx() { if (!VirtualPendingOrders && !VirtualStops) { return (OrderOpenPrice()); } return (a_open_price[vo_sel_ind]); } double OrderStopLossEx() { if (!VirtualPendingOrders && !VirtualStops) { return (OrderStopLoss()); } return (a_sl[vo_sel_ind]); } double OrderTakeProfitEx() { if (!VirtualPendingOrders && !VirtualStops) { return (OrderTakeProfit()); } return (a_tp[vo_sel_ind]); } int OrderMagicNumberEx() { if (!VirtualPendingOrders && !VirtualStops) { return (OrderMagicNumber()); } return (a_magic[vo_sel_ind]); } void LoadStops() { string obj_name, txt; int size = ArraySize(a_tickets); for (int i=0; i= NormalizeDouble(a_open_price[i], Digits)) { ticket = OrderSend(Symbol(), OP_BUY, a_volume[i], Ask, Slippage, sl, tp, a_comment[i], a_magic[i], 0, a_color[i]); if (ticket >= 0) { a_tickets[i] = ticket; a_type[i] = OP_BUY; } } } else if (a_type[i] == OP_BUYLIMIT) { if (NormalizeDouble(Ask, Digits) <= NormalizeDouble(a_open_price[i], Digits)) { ticket = OrderSend(Symbol(), OP_BUY, a_volume[i], Ask, Slippage, sl, tp, a_comment[i], a_magic[i], 0, a_color[i]); if (ticket >= 0) { a_tickets[i] = ticket; a_type[i] = OP_BUY; } } } else if (a_type[i] == OP_SELLSTOP) { if (NormalizeDouble(Bid, Digits) <= NormalizeDouble(a_open_price[i], Digits)) { ticket = OrderSend(Symbol(), OP_SELL, a_volume[i], Bid, Slippage, sl, tp, a_comment[i], a_magic[i], 0, a_color[i]); if (ticket >= 0) { a_tickets[i] = ticket; a_type[i] = OP_SELL; } } } else if (a_type[i] == OP_SELLLIMIT) { if (NormalizeDouble(Bid, Digits) >= NormalizeDouble(a_open_price[i], Digits)) { ticket = OrderSend(Symbol(), OP_SELL, a_volume[i], Bid, Slippage, sl, tp, a_comment[i], a_magic[i], 0, a_color[i]); if (ticket >= 0) { a_tickets[i] = ticket; a_type[i] = OP_SELL; } } } } } void VO_UpdatePOType() { int size = a_N; for (int i=size-1; i>=0; i--) { int ticket = a_tickets[i]; if (!OrderSelect(ticket, SELECT_BY_TICKET)) continue; if (OrderCloseTime() > 0) { VOrderRemove(i); continue; } //----- if (OrderType() == OP_BUY) { if (a_type[i] == OP_BUYSTOP || a_type[i] == OP_BUYLIMIT) a_type[i] = OP_BUY; continue; } if (OrderType() == OP_SELL) { if (a_type[i] == OP_SELLSTOP || a_type[i] == OP_SELLLIMIT) a_type[i] = OP_SELL; continue; } } } void VO_CheckStops() { bool bRC; int size = a_N; for (int i=0; i 0) continue; //----- RefreshRates(); int StopLevel = MarketInfo(OrderSymbol(), MODE_STOPLEVEL) + 1; double bid = MarketInfo(OrderSymbol(), MODE_BID); double ask = MarketInfo(OrderSymbol(), MODE_ASK); int digits = MarketInfo(OrderSymbol(), MODE_DIGITS); double point = MarketInfo(OrderSymbol(), MODE_POINT); double sl = a_sl[i]; double tp = a_tp[i]; int type = OrderType(); if (type == OP_BUY) { if (NormalizeDouble(bid, digits) > NormalizeDouble(tp, digits) && tp > 0) { Print("[CheckStops] Close BUY by VirtualTP ", DoubleToStr(tp, digits)); bRC = OrderClose(ticket, OrderLots(), bid, Slippage*fpc()); if (bRC) { //bRC = OrderSelect(ticket, SELECT_BY_TICKET); //AddStopsHist(ticket, OrderStopLossEx(), OrderTakeProfitEx(), "[tp]"); } continue; } if (NormalizeDouble(bid, digits) < NormalizeDouble(sl, digits) && sl > 0) { Print("[CheckStops] Close BUY by VirtualSL ", DoubleToStr(sl, digits)); bRC = OrderClose(ticket, OrderLots(), bid, Slippage*fpc()); if (bRC) { //bRC = OrderSelect(ticket, SELECT_BY_TICKET); //AddStopsHist(ticket, OrderStopLossEx(), OrderTakeProfitEx(), "[sl]"); } continue; } } if (type == OP_SELL) { if (NormalizeDouble(ask, digits) < NormalizeDouble(tp, digits) && tp > 0) { Print("[CheckStops] Close SELL by VirtualTP ", DoubleToStr(tp, digits)); bRC = OrderClose(ticket, OrderLots(), ask, Slippage*fpc()); if (bRC) { //bRC = OrderSelect(ticket, SELECT_BY_TICKET); //AddStopsHist(ticket, OrderStopLossEx(), OrderTakeProfitEx(), "[tp]"); } continue; } if (NormalizeDouble(ask, digits) > NormalizeDouble(sl, digits) && sl > 0) { Print("[CheckStops] Close SELL by VirtualSL ", DoubleToStr(sl, digits)); bRC = OrderClose(ticket, OrderLots(), ask, Slippage*fpc()); if (bRC) { //bRC = OrderSelect(ticket, SELECT_BY_TICKET); //AddStopsHist(ticket, OrderStopLossEx(), OrderTakeProfitEx(), "[sl]"); } continue; } } } } void VO_ClearStops() { int size = a_N; for (int i=size-1; i>=0; i--) { if (a_type[i] != OP_BUY && a_type[i] != OP_SELL) continue; int ticket = a_tickets[i]; bool bRemove = false; if (!OrderSelect(ticket, SELECT_BY_TICKET)) bRemove = true; if (OrderCloseTime() > 0) bRemove = true; if (bRemove) { VOrderRemove(i); } } } void VOrderRemove(int ind) { for (int j=ind; j < a_N-1; j++) { a_tickets[j] = a_tickets[j+1]; a_type[j] = a_type[j+1]; a_symbol[j] = a_symbol[j+1]; a_volume[j] = a_volume[j+1]; a_open_price[j] = a_open_price[j+1]; a_sl[j] = a_sl[j+1]; a_tp[j] = a_tp[j+1]; a_magic[j] = a_magic[j+1]; a_comment[j] = a_comment[j+1]; a_color[j] = a_color[j+1]; } a_N--; } void VO_DrawStops() { string obj_name, txt; obj_name = vo_prefix + "Legend"; if (ObjectFind(obj_name) == -1) { ObjectCreate(obj_name, OBJ_LABEL, 0, 0, 0); } txt = "Virtual Orders Storage"; ObjectSetText(obj_name, txt, VOrdText_font_size, VOrdText_font, VOrdText_font_color); ObjectSet(obj_name, OBJPROP_CORNER, VOrdText_corner); ObjectSet(obj_name, OBJPROP_XDISTANCE, VOrdText_x); ObjectSet(obj_name, OBJPROP_YDISTANCE, VOrdText_y); //----- string VOTable_ColPref[10] = {"ticket", "type", "volume", "symbol", "open_price", "sl", "tp", "magic", "comment", "color"}; string VOTableText[][10]; ArrayResize(VOTableText, a_N); int i, j; int size = a_N; for (i=0; i=0; j--) { obj_name = vo_prefix + "ord" + string(i) + "_" + VOTable_ColPref[j]; if (ObjectFind(obj_name) == -1) { ObjectCreate(obj_name, OBJ_LABEL, 0, 0, 0); } txt = VOTableText[i][j]; ObjectSetText(obj_name, txt, VOrdText_font_size, VOrdText_font, VOrdText_font_color); ObjectSet(obj_name, OBJPROP_CORNER, VOrdText_corner); if (j >= 7) ObjectSet(obj_name, OBJPROP_XDISTANCE, 10000); else ObjectSet(obj_name, OBJPROP_XDISTANCE, dx); ObjectSet(obj_name, OBJPROP_YDISTANCE, VOrdText_y + (i+1)*VOrdText_dy); if (j < 7) { dx += VOrdText_dx; } } } //----- for (; i<1000; i++) { obj_name = vo_prefix + "ord" + string(i); if (ObjectFind(obj_name) != -1) ObjectDelete(obj_name); } } string OrdType2Str(int type) { switch (type) { case OP_BUY: return ("Buy"); case OP_SELL: return ("Sell"); case OP_BUYLIMIT: return ("BuyLimit"); case OP_SELLLIMIT: return ("SellLimit"); case OP_BUYSTOP: return ("BuyStop"); case OP_SELLSTOP: return ("SellStop"); } return (""+type); } int Str2OrdType(string sType) { if (sType == "Buy") return (OP_BUY); if (sType == "Sell") return (OP_SELL); if (sType == "BuyLimit") return (OP_BUYLIMIT); if (sType == "SellLimit") return (OP_SELLLIMIT); if (sType == "BuyStop") return (OP_BUYSTOP); if (sType == "SellStop") return (OP_SELLSTOP); return (-1); } int fpc() { if (Digits == 3 || Digits == 5) return (10); return (1); } //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~