// Id: 24142 #property version "1.00" #property strict extern int ema_1_period = 7; // EMA #1 period extern int ema_2_period = 14; // EMA #2 period extern ENUM_TIMEFRAMES base_timeframe_1 = PERIOD_CURRENT; // Base timeframe #1 extern int timeframe_count_1 = 1; // Number of bars #1 extern ENUM_TIMEFRAMES base_timeframe_2 = PERIOD_CURRENT; // Base timeframe #2 extern int timeframe_count_2 = 1; // Number of bars #2 // Trade controller v.2.11 #define LIVE_TRADING #define REVERSABLE_LOGIC_FEATURE extern #define STOP_LOSS_FEATURE extern #define TAKE_PROFIT_FEATURE extern #define WEEKLY_TRADING_TIME_FEATURE extern #define TRADING_TIME_FEATURE extern #define POSITION_CAP_FEATURE extern extern string GeneralSection = ""; // == General == enum PositionSizeType { PositionSizeAmount, // $ PositionSizeContract, // In contracts PositionSizeEquity, // % of equity PositionSizeRisk // Risk in % of equity }; enum LogicDirection { DirectLogic, // Direct ReversalLogic // Reversal }; enum TradingSide { LongSideOnly, // Long ShortSideOnly, // Short BothSides // Both }; extern double lots_value = 0.1; // Position size extern PositionSizeType lots_type = PositionSizeContract; // Position size type extern int slippage_points = 3; // Slippage, points extern TradingSide trading_side = BothSides; // What trades should be taken REVERSABLE_LOGIC_FEATURE LogicDirection logic_direction = DirectLogic; // Logic type extern bool close_on_opposite = true; // Close on opposite signal POSITION_CAP_FEATURE string CapSection = ""; // == Position cap == POSITION_CAP_FEATURE bool position_cap = false; // Position Cap POSITION_CAP_FEATURE int no_of_positions = 1; // Max # of buy+sell positions POSITION_CAP_FEATURE int no_of_buy_position = 1; // Max # of buy positions POSITION_CAP_FEATURE int no_of_sell_position = 1; // Max # of sell positions STOP_LOSS_FEATURE string StopLossSection = ""; // == Stop loss == enum TrailingType { TrailingDontUse, // No trailing TrailingPips, // Use trailing in pips TrailingPercent // Use trailing in % of stop }; enum StopLimitType { StopLimitDoNotUse, // Do not use StopLimitPercent, // Set in % StopLimitPips, // Set in Pips StopLimitDollar, // Set in $, StopLimitRiskReward, // Set in % of stop loss StopLimitAbsolute // Set in absolite value (rate) }; STOP_LOSS_FEATURE StopLimitType stop_loss_type = StopLimitDoNotUse; // Stop loss type STOP_LOSS_FEATURE double stop_loss_value = 10; // Stop loss value STOP_LOSS_FEATURE TrailingType trailing_type = TrailingDontUse; // Trailing type STOP_LOSS_FEATURE double trailing_start = 0; // Trailing start, pips of profit STOP_LOSS_FEATURE double trailing_step = 10; // Trailing step STOP_LOSS_FEATURE StopLimitType breakeven_type = StopLimitDoNotUse; // Trigger type for the breakeven STOP_LOSS_FEATURE double breakeven_value = 10; // Trigger for the breakeven STOP_LOSS_FEATURE double breakeven_level = 0; // Breakeven target TAKE_PROFIT_FEATURE string TakeProfitSection = ""; // == Take Profit == TAKE_PROFIT_FEATURE StopLimitType take_profit_type = StopLimitDoNotUse; // Take profit type TAKE_PROFIT_FEATURE double take_profit_value = 10; // Take profit value enum DayOfWeek { DayOfWeekSunday = 0, // Sunday DayOfWeekMonday = 1, // Monday DayOfWeekTuesday = 2, // Tuesday DayOfWeekWednesday = 3, // Wednesday DayOfWeekThursday = 4, // Thursday DayOfWeekFriday = 5, // Friday DayOfWeekSaturday = 6 // Saturday }; TRADING_TIME_FEATURE string OtherSection = ""; // == Other == TRADING_TIME_FEATURE int magic_number = 42; // Magic number TRADING_TIME_FEATURE string start_time = "000000"; // Start time in hhmmss format TRADING_TIME_FEATURE string stop_time = "000000"; // Stop time in hhmmss format WEEKLY_TRADING_TIME_FEATURE bool use_weekly_timing = false; // Weekly time WEEKLY_TRADING_TIME_FEATURE DayOfWeek week_start_day = DayOfWeekSunday; // Start day WEEKLY_TRADING_TIME_FEATURE string week_start_time = "000000"; // Start time in hhmmss format WEEKLY_TRADING_TIME_FEATURE DayOfWeek week_stop_day = DayOfWeekSaturday; // Stop day WEEKLY_TRADING_TIME_FEATURE string week_stop_time = "235959"; // Stop time in hhmmss format WEEKLY_TRADING_TIME_FEATURE bool mandatory_closing = false; // Mandatory closing for non-trading time //Signaler v 1.5 extern string AlertsSection = ""; // == Alerts == extern bool Popup_Alert = true; // Popup message extern bool Notification_Alert = false; // Push notification extern bool Email_Alert = false; // Email extern bool Play_Sound = false; // Play sound on alert extern string Sound_File = ""; // Sound file extern bool Advanced_Alert = false; // Advanced alert extern string Advanced_Key = ""; // Advanced alert key extern string Comment2 = "- You can get a advanced alert key by starting a dialog with @profit_robots_bot Telegram bot -"; extern string Comment3 = "- Allow use of dll in the indicator parameters window -"; extern string Comment4 = "- Install AdvancedNotificationsLib.dll -"; // AdvancedNotificationsLib.dll could be downloaded here: http://profitrobots.com/Home/TelegramNotificationsMT4 #import "AdvancedNotificationsLib.dll" void AdvancedAlert(string key, string text, string instrument, string timeframe); #import #define ENTER_BUY_SIGNAL 1 #define ENTER_SELL_SIGNAL -1 #define EXIT_BUY_SIGNAL 2 #define EXIT_SELL_SIGNAL -2 class Signaler { string _symbol; ENUM_TIMEFRAMES _timeframe; datetime _lastDatetime; public: Signaler(const string symbol, ENUM_TIMEFRAMES timeframe) { _symbol = symbol; _timeframe = timeframe; } void SendNotifications(const int direction) { if (direction == 0) return; datetime currentTime = iTime(_symbol, _timeframe, 0); if (_lastDatetime == currentTime) return; _lastDatetime = currentTime; string tf = GetTimeframe(); string alert_Subject; string alert_Body; switch (direction) { case ENTER_BUY_SIGNAL: alert_Subject = "Buy signal on " + _symbol + "/" + tf; alert_Body = "Buy signal on " + _symbol + "/" + tf; break; case ENTER_SELL_SIGNAL: alert_Subject = "Sell signal on " + _symbol + "/" + tf; alert_Body = "Sell signal on " + _symbol + "/" + tf; break; case EXIT_BUY_SIGNAL: alert_Subject = "Exit buy signal on " + _symbol + "/" + tf; alert_Body = "Exit buy signal on " + _symbol + "/" + tf; break; case EXIT_SELL_SIGNAL: alert_Subject = "Exit sell signal on " + _symbol + "/" + tf; alert_Body = "Exit sell signal on " + _symbol + "/" + tf; break; } SendNotifications(alert_Subject, alert_Body, _symbol, tf); } void SendNotifications(const string subject, string message = NULL, string symbol = NULL, string timeframe = NULL) { if (message == NULL) message = subject; if (symbol == NULL) symbol = _symbol; if (timeframe == NULL) timeframe = GetTimeframe(); if (Popup_Alert) Alert(message); if (Email_Alert) SendMail(subject, message); if (Play_Sound) PlaySound(Sound_File); if (Notification_Alert) SendNotification(message); if (Advanced_Alert && Advanced_Key != "" && !IsTesting()) AdvancedAlert(Advanced_Key, message, symbol, timeframe); } private: string GetTimeframe() { switch (_timeframe) { case PERIOD_M1: return "M1"; case PERIOD_M5: return "M5"; case PERIOD_D1: return "D1"; case PERIOD_H1: return "H1"; case PERIOD_H4: return "H4"; case PERIOD_M15: return "M15"; case PERIOD_M30: return "M30"; case PERIOD_MN1: return "MN1"; case PERIOD_W1: return "W1"; } return "M1"; } }; // Instrument info v.1.2 class InstrumentInfo { string _symbol; double _mult; double _point; double _pipSize; int _digits; double _tickSize; public: InstrumentInfo(const string symbol) { _symbol = symbol; _point = MarketInfo(symbol, MODE_POINT); _digits = (int)MarketInfo(symbol, MODE_DIGITS); _mult = _digits == 3 || _digits == 5 ? 10 : 1; _pipSize = _point * _mult; _tickSize = MarketInfo(_symbol, MODE_TICKSIZE); } static double GetBid(const string symbol) { return MarketInfo(symbol, MODE_BID); } double GetBid() { return GetBid(_symbol); } static double GetAsk(const string symbol) { return MarketInfo(symbol, MODE_ASK); } double GetAsk() { return GetAsk(_symbol); } double GetPipSize() { return _pipSize; } double GetPointSize() { return _point; } string GetSymbol() { return _symbol; } double GetSpread() { return (GetAsk() - GetBid()) / GetPipSize(); } int GetDigits() { return _digits; } double GetTickSize() { return _tickSize; } double RoundRate(const double rate) { return NormalizeDouble(MathCeil(rate / _tickSize + 0.5) * _tickSize, _digits); } }; interface ICondition { public: virtual bool IsPass(const int period) = 0; }; interface IConditionFactory { public: virtual ICondition *CreateCondition(const int order) = 0; }; class ABaseCondition : public ICondition { protected: ENUM_TIMEFRAMES _timeframe; InstrumentInfo *_instrument; string _symbol; public: ABaseCondition(const string symbol, ENUM_TIMEFRAMES timeframe) { _instrument = new InstrumentInfo(symbol); _timeframe = timeframe; _symbol = symbol; } ~ABaseCondition() { delete _instrument; } }; class LongCondition : public ABaseCondition { public: LongCondition(const string symbol, ENUM_TIMEFRAMES timeframe) :ABaseCondition(symbol, timeframe) { } bool IsPass(const int period) { double ema0_1 = iMA(_symbol, _timeframe, ema_1_period, 0, MODE_EMA, PRICE_CLOSE, period); double ema1_1 = iMA(_symbol, _timeframe, ema_1_period, 0, MODE_EMA, PRICE_CLOSE, period + 1); double ema0_2 = iMA(_symbol, _timeframe, ema_2_period, 0, MODE_EMA, PRICE_CLOSE, period); double ema1_2 = iMA(_symbol, _timeframe, ema_2_period, 0, MODE_EMA, PRICE_CLOSE, period + 1); double val1 = iCustom(_symbol, _timeframe, "sideways_bias", base_timeframe_1, timeframe_count_1, 0, period); double val2 = iCustom(_symbol, _timeframe, "sideways_bias", base_timeframe_2, timeframe_count_2, 0, period); return ((ema0_1 > ema0_2 && ema1_1 <= ema1_2) || (ema0_1 < ema0_2 && ema1_1 >= ema1_2)) && val1 == 2 && val2 == 2; } }; class ExitLongCondition : public ABaseCondition { public: ExitLongCondition(const string symbol, ENUM_TIMEFRAMES timeframe) :ABaseCondition(symbol, timeframe) { } bool IsPass(const int period) { //TODO: implement return false; } }; class ShortCondition : public ABaseCondition { public: ShortCondition(const string symbol, ENUM_TIMEFRAMES timeframe) :ABaseCondition(symbol, timeframe) { } bool IsPass(const int period) { double ema0_1 = iMA(_symbol, _timeframe, ema_1_period, 0, MODE_EMA, PRICE_CLOSE, period); double ema1_1 = iMA(_symbol, _timeframe, ema_1_period, 0, MODE_EMA, PRICE_CLOSE, period + 1); double ema0_2 = iMA(_symbol, _timeframe, ema_2_period, 0, MODE_EMA, PRICE_CLOSE, period); double ema1_2 = iMA(_symbol, _timeframe, ema_2_period, 0, MODE_EMA, PRICE_CLOSE, period + 1); double val1 = iCustom(_symbol, _timeframe, "sideways_bias", base_timeframe_1, timeframe_count_1, 0, period); double val2 = iCustom(_symbol, _timeframe, "sideways_bias", base_timeframe_2, timeframe_count_2, 0, period); return ((ema0_1 > ema0_2 && ema1_1 <= ema1_2) || (ema0_1 < ema0_2 && ema1_1 >= ema1_2)) && val1 == -2 && val2 == -2; } }; class ExitShortCondition : public ABaseCondition { public: ExitShortCondition(const string symbol, ENUM_TIMEFRAMES timeframe) :ABaseCondition(symbol, timeframe) { } bool IsPass(const int period) { //TODO: implement return false; } }; // Custom exit logic v. 1.0 interface ICustomExitLogic { public: virtual void DoLogic() = 0; virtual void Create(const int order) = 0; }; class DisabledCustomExitLogic : public ICustomExitLogic { public: void DoLogic() {} void Create(const int order) {} }; interface IAction { public: virtual void DoAction() = 0; virtual bool SetOrder(const int order) = 0; }; class CustomExitAction : public IAction { int _order; bool _finished; public: CustomExitAction() { _finished = true; } virtual void DoAction() { if (_finished || !OrderSelect(_order, SELECT_BY_TICKET, MODE_TRADES)) { _finished = true; return; } } virtual bool SetOrder(const int order) { if (!_finished) return false; if (!OrderSelect(order, SELECT_BY_TICKET, MODE_TRADES)) return false; _order = order; return true; } }; class CustomExitLogic : public ICustomExitLogic { IAction *_actions[]; public: CustomExitLogic() { } ~CustomExitLogic() { int i_count = ArraySize(_actions); for (int i = 0; i < i_count; ++i) { delete _actions[i]; } } void DoLogic() { int i_count = ArraySize(_actions); for (int i = 0; i < i_count; ++i) { _actions[i].DoAction(); } } void Create(const int order) { if (!OrderSelect(order, SELECT_BY_TICKET, MODE_TRADES) || OrderCloseTime() != 0.0) return; int i_count = ArraySize(_actions); for (int i = 0; i < i_count; ++i) { if (_actions[i].SetOrder(order)) { return; } } ArrayResize(_actions, i_count + 1); _actions[i_count] = new CustomExitAction(); _actions[i_count].SetOrder(order); } }; // Stream v.1.1 interface IStream { public: virtual bool GetValue(const int period, double &val) = 0; }; interface IBarStream : public IStream { public: virtual bool GetValues(const int period, double &open, double &high, double &low, double &close) = 0; virtual bool GetHighLow(const int period, double &high, double &low) = 0; virtual bool GetIsAscending(const int period, bool &res) = 0; virtual bool GetIsDescending(const int period, bool &res) = 0; }; class BarStream : public IBarStream { string _symbol; ENUM_TIMEFRAMES _timeframe; public: BarStream(const string symbol, const ENUM_TIMEFRAMES timeframe) { _symbol = symbol; _timeframe = timeframe; } virtual bool GetValue(const int period, double &val) { if (iBars(_symbol, _timeframe) <= period) return false; val = iClose(_symbol, _timeframe, period); return true; } virtual bool GetValues(const int period, double &open, double &high, double &low, double &close) { if (iBars(_symbol, _timeframe) <= period) return false; open = iOpen(_symbol, _timeframe, period); high = iHigh(_symbol, _timeframe, period); low = iLow(_symbol, _timeframe, period); close = iClose(_symbol, _timeframe, period); return true; } virtual bool GetHighLow(const int period, double &high, double &low) { if (iBars(_symbol, _timeframe) <= period) return false; high = iHigh(_symbol, _timeframe, period); low = iLow(_symbol, _timeframe, period); return true; } virtual bool GetIsAscending(const int period, bool &res) { if (iBars(_symbol, _timeframe) <= period) return false; res = iOpen(_symbol, _timeframe, period) < iClose(_symbol, _timeframe, period); return true; } virtual bool GetIsDescending(const int period, bool &res) { if (iBars(_symbol, _timeframe) <= period) return false; res = iOpen(_symbol, _timeframe, period) > iClose(_symbol, _timeframe, period); return true; } }; class CandleBodyBarStream : public IBarStream { IBarStream *_source; public: CandleBodyBarStream(IBarStream *source) { _source = source; } virtual bool GetValue(const int period, double &val) { return _source.GetValue(period, val); } virtual bool GetValues(const int period, double &open, double &high, double &low, double &close) { if (!_source.GetValues(period, open, high, low, close)) return false; high = MathMax(open, close); low = MathMin(open, close); return true; } virtual bool GetHighLow(const int period, double &high, double &low) { double open, close; if (!_source.GetValues(period, open, high, low, close)) return false; high = MathMax(open, close); low = MathMin(open, close); return true; } virtual bool GetIsAscending(const int period, bool &res) { return _source.GetIsAscending(period, res); } virtual bool GetIsDescending(const int period, bool &res) { return _source.GetIsDescending(period, res); } }; class CustomTimeframeBarStream : public IBarStream { string _symbol; ENUM_TIMEFRAMES _timeframe; int _timeframeMult; public: CustomTimeframeBarStream(const string symbol, const ENUM_TIMEFRAMES timeframe, int timeframeMult) { _symbol = symbol; _timeframe = timeframe; _timeframeMult = timeframeMult; } virtual bool GetValue(const int period, double &val) { int startIndex, endIndex; if (!GetPeriods(period, startIndex, endIndex)) return false; val = iClose(_symbol, _timeframe, endIndex); return true; } virtual bool GetValues(const int period, double &open, double &high, double &low, double &close) { int startIndex, endIndex; if (!GetPeriods(period, startIndex, endIndex)) return false; open = iOpen(_symbol, _timeframe, startIndex); high = iHigh(_symbol, _timeframe, startIndex); low = iLow(_symbol, _timeframe, startIndex); close = iClose(_symbol, _timeframe, endIndex); for (int i = startIndex - 1; i >= endIndex; --i) { high = MathMax(high, iHigh(_symbol, _timeframe, startIndex)); low = MathMin(low, iLow(_symbol, _timeframe, startIndex)); } return true; } virtual bool GetHighLow(const int period, double &high, double &low) { int startIndex, endIndex; if (!GetPeriods(period, startIndex, endIndex)) return false; low = iLow(_symbol, _timeframe, startIndex); for (int i = startIndex - 1; i >= endIndex; --i) { high = MathMax(high, iHigh(_symbol, _timeframe, startIndex)); low = MathMin(low, iLow(_symbol, _timeframe, startIndex)); } return true; } virtual bool GetIsAscending(const int period, bool &res) { int startIndex, endIndex; if (!GetPeriods(period, startIndex, endIndex)) return false; res = iOpen(_symbol, _timeframe, startIndex) < iClose(_symbol, _timeframe, endIndex); return true; } virtual bool GetIsDescending(const int period, bool &res) { int startIndex, endIndex; if (!GetPeriods(period, startIndex, endIndex)) return false; res = iOpen(_symbol, _timeframe, startIndex) > iClose(_symbol, _timeframe, endIndex); return true; } private: bool GetPeriods(const int period, int &start, int &end) { if (iBars(_symbol, _timeframe) <= period) return false; int periodLength = ((int)_timeframe * _timeframeMult * 60); datetime barStart = (Time[period] / periodLength) * periodLength; start = iBarShift(_symbol, _timeframe, barStart); end = iBarShift(_symbol, _timeframe, barStart + periodLength) + 1; if (start < end) end = start; return true; } }; interface IStreamFactory { public: virtual IStream *Create(const int order) = 0; }; class DisabledCondition : public ICondition { public: bool IsPass(const int period) { return false; } }; class NoCondition : public ICondition { public: bool IsPass(const int period) { return true; } }; enum OrderSide { BuySide, SellSide }; // Orders iterator v 1.7 enum CompareType { CompareLessThan }; class OrdersIterator { bool _useMagicNumber; int _magicNumber; bool _useOrderType; int _orderType; bool _trades; bool _useSide; bool _isBuySide; int _lastIndex; bool _useSymbol; string _symbol; bool _useProfit; double _profit; CompareType _profitCompare; bool _orders; public: OrdersIterator() { _useOrderType = false; _useMagicNumber = false; _useSide = false; _lastIndex = INT_MIN; _trades = false; _useSymbol = false; _useProfit = false; _orders = false; } OrdersIterator *WhenSymbol(const string symbol) { _useSymbol = true; _symbol = symbol; return &this; } OrdersIterator *WhenProfit(const double profit, const CompareType compare) { _useProfit = true; _profit = profit; _profitCompare = compare; return &this; } OrdersIterator *WhenTrade() { _trades = true; return &this; } OrdersIterator *WhenOrder() { _orders = true; return &this; } OrdersIterator *WhenSide(const OrderSide side) { _useSide = true; _isBuySide = side == BuySide; return &this; } OrdersIterator *WhenOrderType(const int orderType) { _useOrderType = true; _orderType = orderType; return &this; } OrdersIterator *WhenMagicNumber(const int magicNumber) { _useMagicNumber = true; _magicNumber = magicNumber; return &this; } int GetOrderType() { return OrderType(); } double GetProfit() { return OrderProfit(); } double IsBuy() { return OrderType() == OP_BUY; } double IsSell() { return OrderType() == OP_SELL; } int Count() { int count = 0; for (int i = OrdersTotal() - 1; i >= 0; i--) { if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES) && PassFilter()) { count++; } } return count; } bool Next() { if (_lastIndex == INT_MIN) { _lastIndex = OrdersTotal() - 1; } else _lastIndex = _lastIndex - 1; while (_lastIndex >= 0) { if (OrderSelect(_lastIndex, SELECT_BY_POS, MODE_TRADES) && PassFilter()) return true; _lastIndex = _lastIndex - 1; } return false; } bool Any() { for (int i = OrdersTotal() - 1; i >= 0; i--) { if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES) && PassFilter()) { return true; } } return false; } private: bool PassFilter() { if (_useMagicNumber && OrderMagicNumber() != _magicNumber) return false; if (_useOrderType && OrderType() != _orderType) return false; if (_trades && !IsTrade()) return false; if (_orders && IsTrade()) return false; if (_useSymbol && OrderSymbol() != _symbol) return false; if (_useProfit) { switch (_profitCompare) { case CompareLessThan: if (OrderProfit() >= _profit) return false; break; } } if (_useSide) { if (_trades) { if (_isBuySide && !IsBuy()) return false; if (!_isBuySide && !IsSell()) return false; } else { //TODO: IMPLEMENT!!!! } } return true; } bool IsTrade() { return (OrderType() == OP_BUY || OrderType() == OP_SELL) && OrderCloseTime() == 0.0; } }; // Trade calculator v.1.13 class TradeCalculator { InstrumentInfo *_symbol; TradeCalculator(const string symbol) { _symbol = new InstrumentInfo(symbol); } public: static TradeCalculator *Create(const string symbol) { ResetLastError(); double temp = MarketInfo(symbol, MODE_POINT); if (GetLastError() != 0) return NULL; return new TradeCalculator(symbol); } ~TradeCalculator() { delete _symbol; } double GetPipSize() { return _symbol.GetPipSize(); } string GetSymbol() { return _symbol.GetSymbol(); } double GetBid() { return _symbol.GetBid(); } double GetAsk() { return _symbol.GetAsk(); } int GetDigits() { return _symbol.GetDigits(); } double GetSpread() { return _symbol.GetSpread(); } static bool IsBuyOrder() { switch (OrderType()) { case OP_BUY: case OP_BUYLIMIT: case OP_BUYSTOP: return true; } return false; } double GetBreakevenPrice(const int side, const int magicNumber, double &totalAmount) { totalAmount = 0.0; double lotStep = SymbolInfoDouble(_symbol.GetSymbol(), SYMBOL_VOLUME_STEP); double price = side == OP_BUY ? GetBid() : GetAsk(); double totalPL = 0; OrdersIterator it1(); it1.WhenMagicNumber(magicNumber); it1.WhenSymbol(_symbol.GetSymbol()); it1.WhenOrderType(side); while (it1.Next()) { double orderLots = OrderLots(); totalAmount += orderLots / lotStep; if (side == OP_BUY) totalPL += (price - OrderOpenPrice()) * (OrderLots() / lotStep); else totalPL += (OrderOpenPrice() - price) * (OrderLots() / lotStep); } if (totalAmount == 0.0) return 0.0; double shift = -(totalPL / totalAmount); return side == OP_BUY ? price + shift : price - shift; } double CalculateTakeProfit(const bool isBuy, const double takeProfit, const StopLimitType takeProfitType, const double amount, double basePrice) { int direction = isBuy ? 1 : -1; switch (takeProfitType) { case StopLimitPercent: return RoundRate(basePrice + basePrice * takeProfit / 100.0 * direction); case StopLimitPips: return RoundRate(basePrice + takeProfit * _symbol.GetPipSize() * direction); case StopLimitDollar: return RoundRate(basePrice + CalculateSLShift(amount, takeProfit) * direction); case StopLimitAbsolute: return takeProfit; } return 0.0; } double CalculateStopLoss(const bool isBuy, const double stopLoss, const StopLimitType stopLossType, const double amount, double basePrice) { int direction = isBuy ? 1 : -1; switch (stopLossType) { case StopLimitPercent: return RoundRate(basePrice - basePrice * stopLoss / 100.0 * direction); case StopLimitPips: return RoundRate(basePrice - stopLoss * _symbol.GetPipSize() * direction); case StopLimitDollar: return RoundRate(basePrice - CalculateSLShift(amount, stopLoss) * direction); case StopLimitAbsolute: return stopLoss; } return 0.0; } double GetLots(PositionSizeType lotsType, double lotsValue, double stopDistance) { switch (lotsType) { case PositionSizeAmount: return GetLotsForMoney(lotsValue); case PositionSizeContract: return LimitLots(RoundLots(lotsValue)); case PositionSizeEquity: return GetLotsForMoney(AccountEquity() * lotsValue / 100.0); case PositionSizeRisk: { double affordableLoss = AccountEquity() * lotsValue / 100.0; double unitCost = MarketInfo(_symbol.GetSymbol(), MODE_TICKVALUE); double tickSize = _symbol.GetTickSize(); double possibleLoss = unitCost * stopDistance / tickSize; if (possibleLoss <= 0.01) return 0; return LimitLots(RoundLots(affordableLoss / possibleLoss)); } } return lotsValue; } bool IsLotsValid(const double lots, PositionSizeType lotsType, string &error) { switch (lotsType) { case PositionSizeContract: return IsContractLotsValid(lots, error); } return true; } double NormalizeLots(const double lots) { return LimitLots(RoundLots(lots)); } double RoundRate(const double rate) { return _symbol.RoundRate(rate); } private: bool IsContractLotsValid(const double lots, string &error) { double minVolume = SymbolInfoDouble(_symbol.GetSymbol(), SYMBOL_VOLUME_MIN); if (minVolume > lots) { error = "Min. allowed lot size is " + DoubleToString(minVolume); return false; } double maxVolume = SymbolInfoDouble(_symbol.GetSymbol(), SYMBOL_VOLUME_MAX); if (maxVolume < lots) { error = "Max. allowed lot size is " + DoubleToString(maxVolume); return false; } return true; } double GetLotsForMoney(const double money) { double marginRequired = MarketInfo(_symbol.GetSymbol(), MODE_MARGINREQUIRED); if (marginRequired <= 0.0) { Print("Margin is 0. Server misconfiguration?"); return 0.0; } double lots = RoundLots(money / marginRequired); return LimitLots(lots); } double RoundLots(const double lots) { double lotStep = SymbolInfoDouble(_symbol.GetSymbol(), SYMBOL_VOLUME_STEP); if (lotStep == 0) return 0.0; return floor(lots / lotStep) * lotStep; } double LimitLots(const double lots) { double minVolume = SymbolInfoDouble(_symbol.GetSymbol(), SYMBOL_VOLUME_MIN); if (minVolume > lots) return 0.0; double maxVolume = SymbolInfoDouble(_symbol.GetSymbol(), SYMBOL_VOLUME_MAX); if (maxVolume < lots) return maxVolume; return lots; } double CalculateSLShift(const double amount, const double money) { double unitCost = MarketInfo(_symbol.GetSymbol(), MODE_TICKVALUE); double tickSize = _symbol.GetTickSize(); return (money / (unitCost / tickSize)) / amount; } }; // Breakeven logic v. 1.9 interface IBreakevenLogic { public: virtual void DoLogic(const int period) = 0; virtual void CreateBreakeven(const int order, const int period) = 0; }; class DisabledBreakevenLogic : public IBreakevenLogic { public: void DoLogic(const int period) {} void CreateBreakeven(const int order, const int period) {} }; class BreakevenController { int _order; bool _finished; double _trigger; double _target; Signaler *_signaler; InstrumentInfo *_instrument; ICondition *_condition; string _name; public: BreakevenController(Signaler *signaler) { _condition = NULL; _instrument = NULL; _signaler = signaler; _finished = true; } ~BreakevenController() { delete _condition; delete _instrument; } bool SetOrder(const int order, const double trigger, const double target, ICondition *condition) { return SetOrder(order, trigger, target, condition, ""); } bool SetOrder(const int order, const double trigger, const double target, ICondition *condition, const string name) { if (!_finished) { return false; } if (!OrderSelect(order, SELECT_BY_TICKET, MODE_TRADES)) return false; string symbol = OrderSymbol(); if (_instrument == NULL || symbol != _instrument.GetSymbol()) { delete _instrument; _instrument = new InstrumentInfo(symbol); } _finished = false; _trigger = trigger; _target = target; _order = order; delete _condition; _name = name; _condition = condition; return true; } void DoLogic(const int period) { if (_finished || !OrderSelect(_order, SELECT_BY_TICKET, MODE_TRADES)) { _finished = true; return; } int type = OrderType(); if (type == OP_BUY) { if (_instrument.GetAsk() >= _trigger || (_condition != NULL && _condition.IsPass(period))) { int ticket = OrderTicket(); if (_signaler != NULL) _signaler.SendNotifications(GetNamePrefix() + "Trade " + IntegerToString(ticket) + " has reached " + DoubleToString(_trigger, _instrument.GetDigits()) + ". Stop loss moved to " + DoubleToString(_target, _instrument.GetDigits())); int res = OrderModify(ticket, OrderOpenPrice(), _target, OrderTakeProfit(), 0, CLR_NONE); _finished = true; } } else if (type == OP_SELL) { if (_instrument.GetBid() < _trigger || (_condition != NULL && _condition.IsPass(period))) { int ticket = OrderTicket(); if (_signaler != NULL) _signaler.SendNotifications(GetNamePrefix() + "Trade " + IntegerToString(ticket) + " has reached " + DoubleToString(_trigger, _instrument.GetDigits()) + ". Stop loss moved to " + DoubleToString(_target, _instrument.GetDigits())); int res = OrderModify(ticket, OrderOpenPrice(), _target, OrderTakeProfit(), 0, CLR_NONE); _finished = true; } } } private: string GetNamePrefix() { if (_name == "") return ""; return _name + ". "; } }; class BreakevenLogic : public IBreakevenLogic { BreakevenController *_breakeven[]; StopLimitType _triggerType; double _trigger; double _target; TradeCalculator *_calculator; Signaler *_signaler; IConditionFactory *_conditionFactory; public: BreakevenLogic(const StopLimitType triggerType, const double trigger, const double target, Signaler *signaler) { Init(); _signaler = signaler; _triggerType = triggerType; _trigger = trigger; _target = target; } BreakevenLogic() { Init(); } ~BreakevenLogic() { delete _conditionFactory; int i_count = ArraySize(_breakeven); for (int i = 0; i < i_count; ++i) { delete _breakeven[i]; } } BreakevenLogic *SetConditionFactory(IConditionFactory *conditionFactory) { _conditionFactory = conditionFactory; return &this; } void DoLogic(const int period) { int i_count = ArraySize(_breakeven); for (int i = 0; i < i_count; ++i) { _breakeven[i].DoLogic(period); } } void CreateBreakeven(const int order, const int period, const StopLimitType triggerType, const double trigger, const double target) { if (triggerType == StopLimitDoNotUse) return; if (!OrderSelect(order, SELECT_BY_TICKET, MODE_TRADES) || OrderCloseTime() != 0.0) return; string symbol = OrderSymbol(); if (_calculator == NULL || symbol != _calculator.GetSymbol()) { delete _calculator; _calculator = TradeCalculator::Create(symbol); if (_calculator == NULL) return; } int isBuy = TradeCalculator::IsBuyOrder(); double basePrice = isBuy ? _calculator.GetAsk() : _calculator.GetBid(); double targetValue = isBuy ? basePrice - target * _calculator.GetPipSize() : basePrice + target * _calculator.GetPipSize(); double triggerValue = _calculator.CalculateTakeProfit(isBuy, trigger, triggerType, OrderLots(), basePrice); ICondition *condition = _conditionFactory == NULL ? NULL : _conditionFactory.CreateCondition(order); CreateBreakeven(order, triggerValue, targetValue, condition); } void CreateBreakeven(const int order, const int period) { CreateBreakeven(order, period, _triggerType, _trigger, _target); } private: void Init() { _calculator = NULL; _conditionFactory = NULL; _signaler = NULL; _triggerType = StopLimitDoNotUse; _trigger = 0; _target = 0; } void CreateBreakeven(const int order, const double trigger, const double target, ICondition *condition) { int i_count = ArraySize(_breakeven); for (int i = 0; i < i_count; ++i) { if (_breakeven[i].SetOrder(order, trigger, target, condition)) return; } ArrayResize(_breakeven, i_count + 1); _breakeven[i_count] = new BreakevenController(_signaler); _breakeven[i_count].SetOrder(order, trigger, target, condition); } }; class NetBreakevenController { int _order; bool _finished; double _trigger; double _target; StopLimitType _triggerType; Signaler *_signaler; TradeCalculator *_calculator; public: NetBreakevenController(TradeCalculator *calculator, Signaler *signaler) { _calculator = calculator; _signaler = signaler; _finished = true; } ~NetBreakevenController() { } bool SetOrder(const int order, const double trigger, const StopLimitType triggerType, const double target) { if (!_finished) { return false; } if (!OrderSelect(order, SELECT_BY_TICKET, MODE_TRADES)) return false; string symbol = OrderSymbol(); if (symbol != _calculator.GetSymbol()) return false; _finished = false; _trigger = trigger; _target = target; _order = order; _triggerType = triggerType; return true; } void DoLogic() { if (_finished || !OrderSelect(_order, SELECT_BY_TICKET, MODE_TRADES)) { _finished = true; return; } int type = OrderType(); double totalAmount; int magicNumber = OrderMagicNumber(); double orderLots = OrderLots(); int ticket = OrderTicket(); double orderOpenPrice = OrderOpenPrice(); double orderTakeProfit = OrderTakeProfit(); double averagePrice = _calculator.GetBreakevenPrice(type, magicNumber, totalAmount); double trigger = _calculator.CalculateTakeProfit(type == OP_BUY, _trigger, _triggerType, orderLots, averagePrice); if (type == OP_BUY) { if (_calculator.GetAsk() >= trigger) { double target = averagePrice + _target * _calculator.GetPipSize(); _signaler.SendNotifications("Trade " + IntegerToString(ticket) + " has reached " + DoubleToString(_trigger, 1) + ". Stop loss moved to " + DoubleToString(target, _calculator.GetDigits())); int res = OrderModify(ticket, orderOpenPrice, target, orderTakeProfit, 0, CLR_NONE); _finished = true; } } else if (type == OP_SELL) { if (_calculator.GetBid() < trigger) { double target = averagePrice - _target * _calculator.GetPipSize(); _signaler.SendNotifications("Trade " + IntegerToString(ticket) + " has reached " + DoubleToString(_trigger, 1) + ". Stop loss moved to " + DoubleToString(target, _calculator.GetDigits())); int res = OrderModify(ticket, orderOpenPrice, target, orderTakeProfit, 0, CLR_NONE); _finished = true; } } } }; class NetBreakevenLogic : public IBreakevenLogic { NetBreakevenController *_breakeven[]; StopLimitType _triggerType; double _trigger; double _target; TradeCalculator *_calculator; Signaler *_signaler; public: NetBreakevenLogic(TradeCalculator *calculator, const StopLimitType triggerType, const double trigger, const double target, Signaler *signaler) { _signaler = signaler; _calculator = calculator; _triggerType = triggerType; _trigger = trigger; _target = target; } ~NetBreakevenLogic() { int i_count = ArraySize(_breakeven); for (int i = 0; i < i_count; ++i) { delete _breakeven[i]; } } void DoLogic() { int i_count = ArraySize(_breakeven); for (int i = 0; i < i_count; ++i) { _breakeven[i].DoLogic(); } } void CreateBreakeven(const int order, const int period) { if (_triggerType == StopLimitDoNotUse) return; if (!OrderSelect(order, SELECT_BY_TICKET, MODE_TRADES) || OrderCloseTime() != 0.0) return; string symbol = OrderSymbol(); if (symbol != _calculator.GetSymbol()) { Print("Error in breakeven logic usage"); return; } int i_count = ArraySize(_breakeven); for (int i = 0; i < i_count; ++i) { if (_breakeven[i].SetOrder(order, _trigger, _triggerType, _target)) { return; } } ArrayResize(_breakeven, i_count + 1); _breakeven[i_count] = new NetBreakevenController(_calculator, _signaler); _breakeven[i_count].SetOrder(order, _trigger, _triggerType, _target); } }; // Trailing controller v.2.3 interface ITrailingLogic { public: virtual void DoLogic() = 0; virtual void Create(const int order, const double stop) = 0; }; class DisabledTrailingLogic : public ITrailingLogic { public: void DoLogic() {}; void Create(const int order, const double stop) {}; }; enum TrailingControllerType { TrailingControllerTypeStandard ,TrailingControllerTypeStream }; interface ITrailingController { public: virtual bool IsFinished() = 0; virtual void UpdateStop() = 0; virtual TrailingControllerType GetType() = 0; }; class StreamTrailingController : public ITrailingController { Signaler *_signaler; int _order; bool _finished; double _distance; IStream *_stream; InstrumentInfo *_instrument; public: StreamTrailingController(Signaler *signaler = NULL) { _instrument = NULL; _stream = NULL; _finished = true; _order = -1; _signaler = signaler; } ~StreamTrailingController() { delete _stream; delete _instrument; } bool IsFinished() { return _finished; } bool SetOrder(const int order, IStream *stream) { if (!_finished) { return false; } if (!OrderSelect(order, SELECT_BY_TICKET, MODE_TRADES) || OrderCloseTime() != 0.0) { return false; } string symbol = OrderSymbol(); if (_instrument == NULL || _instrument.GetSymbol() != symbol) { delete _instrument; _instrument = new InstrumentInfo(symbol); } delete _stream; _stream = stream; _finished = false; _order = order; return true; } void UpdateStop() { if (_finished || !OrderSelect(_order, SELECT_BY_TICKET, MODE_TRADES) || OrderCloseTime() != 0.0) { _finished = true; return; } double newStop; if (!_stream.GetValue(0, newStop)) return; newStop = _instrument.RoundRate(newStop); if (newStop == OrderStopLoss()) return; if (_signaler != NULL) { string message = "Trailing stop loss for " + IntegerToString(_order) + " to " + DoubleToString(newStop, _instrument.GetDigits()); _signaler.SendNotifications(message); } int res = OrderModify(_order, OrderOpenPrice(), newStop, OrderTakeProfit(), 0, CLR_NONE); if (res == 0) { int error = GetLastError(); switch (error) { case ERR_INVALID_TICKET: _finished = true; break; } } } TrailingControllerType GetType() { return TrailingControllerTypeStream; } }; class IndicatorTrailingLogic : public ITrailingLogic { ITrailingController *_trailing[]; InstrumentInfo *_instrument; IStreamFactory *_streamFactory; Signaler *_signaler; public: IndicatorTrailingLogic(IStreamFactory *streamFactory, Signaler *signaler) { _streamFactory = streamFactory; _signaler = signaler; _instrument = NULL; } ~IndicatorTrailingLogic() { delete _streamFactory; delete _instrument; int i_count = ArraySize(_trailing); for (int i = 0; i < i_count; ++i) { delete _trailing[i]; } } void DoLogic() { int i_count = ArraySize(_trailing); for (int i = 0; i < i_count; ++i) { _trailing[i].UpdateStop(); } } void Create(const int order, const double stop) { if (!OrderSelect(order, SELECT_BY_TICKET, MODE_TRADES) || OrderCloseTime() != 0.0) return; string symbol = OrderSymbol(); if (_instrument == NULL) { delete _instrument; _instrument = new InstrumentInfo(symbol); } if (symbol != _instrument.GetSymbol()) { return; } IStream *stream = _streamFactory.Create(order); int i_count = ArraySize(_trailing); for (int i = 0; i < i_count; ++i) { if (_trailing[i].GetType() != TrailingControllerTypeStream) continue; StreamTrailingController *trailingController = (StreamTrailingController *)_trailing[i]; if (trailingController.SetOrder(order, stream)) { return; } } StreamTrailingController *trailingController = new StreamTrailingController(_signaler); trailingController.SetOrder(order, stream); ArrayResize(_trailing, i_count + 1); _trailing[i_count] = trailingController; } }; class TrailingController : public ITrailingController { Signaler *_signaler; int _order; bool _finished; double _distance; double _trailingStep; InstrumentInfo *_instrument; public: TrailingController(Signaler *signaler = NULL) { _finished = true; _order = -1; _signaler = signaler; _instrument = NULL; } ~TrailingController() { delete _instrument; } bool IsFinished() { return _finished; } bool SetOrder(const int order, const double distance, const double trailingStep) { if (!_finished) { return false; } if (!OrderSelect(order, SELECT_BY_TICKET, MODE_TRADES) || OrderCloseTime() != 0.0) { return false; } string symbol = OrderSymbol(); if (_instrument == NULL || _instrument.GetSymbol() != symbol) { delete _instrument; _instrument = new InstrumentInfo(symbol); } _trailingStep = _instrument.RoundRate(trailingStep); if (_trailingStep == 0) return false; _finished = false; _order = order; _distance = distance; return true; } void UpdateStop() { if (_finished || !OrderSelect(_order, SELECT_BY_TICKET, MODE_TRADES) || OrderCloseTime() != 0.0) { _finished = true; return; } int type = OrderType(); if (type == OP_BUY) { UpdateStopForLong(); } else if (type == OP_SELL) { UpdateStopForShort(); } } TrailingControllerType GetType() { return TrailingControllerTypeStandard; } private: void UpdateStopForLong() { double initialStop = OrderStopLoss(); if (initialStop == 0.0) return; double ask = _instrument.GetAsk(); double openPrice = OrderOpenPrice(); if (openPrice > ask + trailing_start * _instrument.GetPipSize()) return; double newStop = initialStop; int digits = _instrument.GetDigits(); while (NormalizeDouble(newStop + _trailingStep, digits) < NormalizeDouble(ask - _distance, digits)) { newStop = NormalizeDouble(newStop + _trailingStep, digits); } if (newStop == initialStop) return; if (_signaler != NULL) { string message = "Trailing stop for " + IntegerToString(_order) + " to " + DoubleToString(newStop, digits); _signaler.SendNotifications(message); } int res = OrderModify(OrderTicket(), openPrice, newStop, OrderTakeProfit(), 0, CLR_NONE); if (res == 0) { int error = GetLastError(); switch (error) { case ERR_INVALID_TICKET: _finished = true; break; } } } void UpdateStopForShort() { double initialStop = OrderStopLoss(); if (initialStop == 0.0) return; double bid = _instrument.GetBid(); double openPrice = OrderOpenPrice(); if (openPrice < bid - trailing_start * _instrument.GetPipSize()) return; double newStop = initialStop; int digits = _instrument.GetDigits(); while (NormalizeDouble(newStop - _trailingStep, digits) > NormalizeDouble(bid + _distance, digits)) { newStop = NormalizeDouble(newStop - _trailingStep, digits); } if (newStop == initialStop) return; if (_signaler != NULL) { string message = "Trailing stop for " + IntegerToString(_order) + " to " + DoubleToString(newStop, digits); _signaler.SendNotifications(message); } int res = OrderModify(OrderTicket(), openPrice, newStop, OrderTakeProfit(), 0, CLR_NONE); if (res == 0) { int error = GetLastError(); switch (error) { case ERR_INVALID_TICKET: _finished = true; break; } } } }; class TrailingLogic : public ITrailingLogic { ITrailingController *_trailing[]; TrailingType _trailingType; double _trailingStep; double _atrTrailingMultiplier; ENUM_TIMEFRAMES _timeframe; InstrumentInfo *_instrument; Signaler *_signaler; public: TrailingLogic(TrailingType trailing, double trailingStep, double atrTrailingMultiplier, ENUM_TIMEFRAMES timeframe, Signaler *signaler) { _signaler = signaler; _instrument = NULL; _trailingType = trailing; _trailingStep = trailingStep; _atrTrailingMultiplier = atrTrailingMultiplier; _timeframe = timeframe; } ~TrailingLogic() { delete _instrument; int i_count = ArraySize(_trailing); for (int i = 0; i < i_count; ++i) { delete _trailing[i]; } } void DoLogic() { int i_count = ArraySize(_trailing); for (int i = 0; i < i_count; ++i) { _trailing[i].UpdateStop(); } } void Create(const int order, const double distancePips, const TrailingType trailingType, const double trailingStep) { if (!OrderSelect(order, SELECT_BY_TICKET, MODE_TRADES) || OrderCloseTime() != 0.0) return; string symbol = OrderSymbol(); if (_instrument == NULL || symbol != _instrument.GetSymbol()) { delete _instrument; _instrument = new InstrumentInfo(symbol); } double distance = distancePips * _instrument.GetPipSize(); switch (trailingType) { case TrailingPips: CreateTrailing(order, distance, trailingStep * _instrument.GetPipSize()); break; case TrailingPercent: CreateTrailing(order, distance, distance * trailingStep / 100.0); break; } } void Create(const int order, const double distancePips) { Create(order, distancePips, _trailingType, _trailingStep); } private: void CreateTrailing(const int order, const double distance, const double trailingStep) { int i_count = ArraySize(_trailing); for (int i = 0; i < i_count; ++i) { if (_trailing[i].GetType() != TrailingControllerTypeStandard) continue; TrailingController *trailingController = (TrailingController *)_trailing[i]; if (trailingController.SetOrder(order, distance, trailingStep)) { return; } } TrailingController *trailingController = new TrailingController(_signaler); trailingController.SetOrder(order, distance, trailingStep); ArrayResize(_trailing, i_count + 1); _trailing[i_count] = trailingController; } }; // Trading time v.1.4 class TradingTime { int _startTime; int _endTime; bool _useWeekTime; int _weekStartTime; int _weekStartDay; int _weekStopTime; int _weekStopDay; public: TradingTime() { _startTime = 0; _endTime = 0; _useWeekTime = false; } bool SetWeekTradingTime(const DayOfWeek startDay, const string startTime, const DayOfWeek stopDay, const string stopTime, string &error) { _useWeekTime = true; _weekStartTime = ParseTime(startTime, error); if (_weekStartTime == -1) return false; _weekStopTime = ParseTime(stopTime, error); if (_weekStopTime == -1) return false; _weekStartDay = (int)startDay; _weekStopDay = (int)stopDay; return true; } bool Init(const string startTime, const string endTime, string &error) { _startTime = ParseTime(startTime, error); if (_startTime == -1) return false; _endTime = ParseTime(endTime, error); if (_endTime == -1) return false; return true; } bool IsTradingTime(datetime dt) { if (_startTime == _endTime && !_useWeekTime) return true; MqlDateTime current_time; if (!TimeToStruct(dt, current_time)) return false; if (!IsIntradayTradingTime(current_time)) return false; return IsWeeklyTradingTime(current_time); } void GetStartEndTime(const datetime date, datetime &start, datetime &end) { MqlDateTime current_time; if (!TimeToStruct(date, current_time)) return; current_time.hour = 0; current_time.min = 0; current_time.sec = 0; datetime referece = StructToTime(current_time); start = referece + _startTime; end = referece + _endTime; if (_startTime > _endTime) { start -= 86400; } } private: bool IsIntradayTradingTime(const MqlDateTime ¤t_time) { if (_startTime == _endTime) return true; int current_t = TimeToInt(current_time); if (_startTime > _endTime) return current_t >= _startTime || current_t <= _endTime; return current_t >= _startTime && current_t <= _endTime; } int TimeToInt(const MqlDateTime ¤t_time) { return (current_time.hour * 60 + current_time.min) * 60 + current_time.sec; } bool IsWeeklyTradingTime(const MqlDateTime ¤t_time) { if (!_useWeekTime) return true; if (current_time.day_of_week < _weekStartDay || current_time.day_of_week > _weekStopDay) return false; if (current_time.day_of_week == _weekStartDay) { int current_t = TimeToInt(current_time); return current_t >= _weekStartTime; } if (current_time.day_of_week == _weekStopDay) { int current_t = TimeToInt(current_time); return current_t < _weekStopTime; } return true; } int ParseTime(const string time, string &error) { int time_parsed = (int)StringToInteger(time); int seconds = time_parsed % 100; if (seconds > 59) { error = "Incorrect number of seconds in " + time; return -1; } time_parsed /= 100; int minutes = time_parsed % 100; if (minutes > 59) { error = "Incorrect number of minutes in " + time; return -1; } time_parsed /= 100; int hours = time_parsed % 100; if (hours > 23) { error = "Incorrect number of hours in " + time; return -1; } return (hours * 60 + minutes) * 60 + seconds; } }; // Money management strategy v.1.3 interface IMoneyManagementStrategy { public: virtual void Get(const int period, const double entryPrice, double &amount, double &stopLoss, double &takeProfit) = 0; }; class AMoneyManagementStrategy : public IMoneyManagementStrategy { protected: TradeCalculator *_calculator; PositionSizeType _lotsType; double _lots; StopLimitType _stopLossType; double _stopLoss; StopLimitType _takeProfitType; double _takeProfit; AMoneyManagementStrategy(TradeCalculator *calculator, PositionSizeType lotsType, double lots , StopLimitType stopLossType, double stopLoss, StopLimitType takeProfitType, double takeProfit) { _calculator = calculator; _lotsType = lotsType; _lots = lots; _stopLossType = stopLossType; _stopLoss = stopLoss; _takeProfitType = takeProfitType; _takeProfit = takeProfit; } }; class LongMoneyManagementStrategy : public AMoneyManagementStrategy { public: LongMoneyManagementStrategy(TradeCalculator *calculator, PositionSizeType lotsType, double lots , StopLimitType stopLossType, double stopLoss, StopLimitType takeProfitType, double takeProfit) : AMoneyManagementStrategy(calculator, lotsType, lots, stopLossType, stopLoss, takeProfitType, takeProfit) { } void Get(const int period, const double entryPrice, double &amount, double &stopLoss, double &takeProfit) { if (_lotsType == PositionSizeRisk) { stopLoss = _calculator.CalculateStopLoss(true, _stopLoss, _stopLossType, 0.0, entryPrice); amount = _calculator.GetLots(_lotsType, _lots, entryPrice - stopLoss); } else { amount = _calculator.GetLots(_lotsType, _lots, 0.0); stopLoss = _calculator.CalculateStopLoss(true, _stopLoss, _stopLossType, amount, entryPrice); } if (_takeProfitType == StopLimitRiskReward) takeProfit = entryPrice + (entryPrice - stopLoss) * _takeProfit / 100; else takeProfit = _calculator.CalculateTakeProfit(true, _takeProfit, _takeProfitType, amount, entryPrice); } }; class ShortMoneyManagementStrategy : public AMoneyManagementStrategy { public: ShortMoneyManagementStrategy(TradeCalculator *calculator, PositionSizeType lotsType, double lots , StopLimitType stopLossType, double stopLoss, StopLimitType takeProfitType, double takeProfit) : AMoneyManagementStrategy(calculator, lotsType, lots, stopLossType, stopLoss, takeProfitType, takeProfit) { } void Get(const int period, const double entryPrice, double &amount, double &stopLoss, double &takeProfit) { if (_lotsType == PositionSizeRisk) { stopLoss = _calculator.CalculateStopLoss(false, _stopLoss, _stopLossType, 0.0, entryPrice); amount = _calculator.GetLots(_lotsType, _lots, stopLoss - entryPrice); } else { amount = _calculator.GetLots(_lotsType, _lots, 0.0); stopLoss = _calculator.CalculateStopLoss(false, _stopLoss, _stopLossType, amount, entryPrice); } if (_takeProfitType == StopLimitRiskReward) takeProfit = entryPrice - (entryPrice - stopLoss) * _takeProfit / 100; else takeProfit = _calculator.CalculateTakeProfit(false, _takeProfit, _takeProfitType, amount, entryPrice); } }; // Trading commands v.2.3 class TradingCommands { public: static void DeleteOrders(const int magicNumber) { OrdersIterator it1(); it1.WhenMagicNumber(magicNumber); it1.WhenOrder(); while (it1.Next()) { int ticket = OrderTicket(); if (!OrderDelete(ticket)) { Print("Failed to delete the order " + IntegerToString(ticket)); } } } static bool DeleteCurrentOrder(string &error) { int ticket = OrderTicket(); if (!OrderDelete(ticket)) { error = "Failed to delete the order " + IntegerToString(ticket); return false; } return true; } static bool CloseCurrentOrder(const int slippage, string &error) { int orderType = OrderType(); if (orderType == OP_BUY) return CloseCurrentOrder(InstrumentInfo::GetBid(OrderSymbol()), slippage, error); if (orderType == OP_SELL) return CloseCurrentOrder(InstrumentInfo::GetAsk(OrderSymbol()), slippage, error); return false; } static bool CloseCurrentOrder(const double price, const int slippage, string &error) { bool closed = OrderClose(OrderTicket(), OrderLots(), price, slippage); if (closed) return true; int lastError = GetLastError(); switch (lastError) { case ERR_TRADE_NOT_ALLOWED: error = "Trading is not allowed"; break; default: error = "Last error: " + IntegerToString(lastError); break; } return false; } static int CloseTrades(OrdersIterator &it, const int slippage) { int closedPositions = 0; while (it.Next()) { int orderType = it.GetOrderType(); string error; if (!CloseCurrentOrder(slippage, error)) Print("Failed to close positoin. ", error); else ++closedPositions; } return closedPositions; } }; // Close on opposite v.1.1 interface ICloseOnOppositeStrategy { public: virtual void DoClose(const OrderSide side) = 0; }; class DontCloseOnOppositeStrategy : public ICloseOnOppositeStrategy { public: void DoClose(const OrderSide side) { // do nothing } }; class DoCloseOnOppositeStrategy : public ICloseOnOppositeStrategy { int _magicNumber; int _slippage; public: DoCloseOnOppositeStrategy(const int slippage, const int magicNumber) { _magicNumber = magicNumber; _slippage = slippage; } void DoClose(const OrderSide side) { OrdersIterator toClose(); toClose.WhenSide(side).WhenMagicNumber(_magicNumber).WhenTrade(); TradingCommands::CloseTrades(toClose, _slippage); } }; // Position cap v.1.1 interface IPositionCapStrategy { public: virtual bool IsLimitHit() = 0; }; class PositionCapStrategy : public IPositionCapStrategy { int _magicNumber; int _maxSidePositions; int _totalPositions; string _symbol; OrderSide _side; public: PositionCapStrategy(const OrderSide side, const int magicNumber, const int maxSidePositions, const int totalPositions, const string symbol = "") { _symbol = symbol; _side = side; _magicNumber = magicNumber; _maxSidePositions = maxSidePositions; _totalPositions = totalPositions; } bool IsLimitHit() { OrdersIterator sideSpecificIterator(); sideSpecificIterator.WhenMagicNumber(_magicNumber).WhenTrade().WhenSide(_side); if (_symbol != "") sideSpecificIterator.WhenSymbol(_symbol); int side_positions = sideSpecificIterator.Count(); if (side_positions >= _maxSidePositions) return true; OrdersIterator it(); it.WhenMagicNumber(_magicNumber).WhenTrade(); if (_symbol != "") it.WhenSymbol(_symbol); int positions = it.Count(); return positions >= _totalPositions; } }; class NoPositionCapStrategy : public IPositionCapStrategy { public: bool IsLimitHit() { return false; } }; // Order builder v.1.1 class OrderBuilder { OrderSide _orderSide; string _instrument; double _amount; double _rate; int _slippage; double _stop; double _limit; int _magicNumber; string _comment; public: OrderBuilder *SetSide(const OrderSide orderSide) { _orderSide = orderSide; return &this; } OrderBuilder *SetInstrument(const string instrument) { _instrument = instrument; return &this; } OrderBuilder *SetAmount(const double amount) { _amount = amount; return &this; } OrderBuilder *SetRate(const double rate) { _rate = NormalizeDouble(rate, Digits); return &this; } OrderBuilder *SetSlippage(const int slippage) { _slippage = slippage; return &this; } OrderBuilder *SetStopLoss(const double stop) { _stop = NormalizeDouble(stop, Digits); return &this; } OrderBuilder *SetTakeProfit(const double limit) { _limit = NormalizeDouble(limit, Digits); return &this; } OrderBuilder *SetMagicNumber(const int magicNumber) { _magicNumber = magicNumber; return &this; } OrderBuilder *SetComment(const string comment) { _comment = comment; return &this; } int Execute(string &errorMessage) { int orderType; if (_orderSide == BuySide) { orderType = _rate > Ask ? OP_BUYSTOP : OP_BUYLIMIT; } else { orderType = _rate < Bid ? OP_SELLSTOP : OP_SELLLIMIT; } double minstoplevel = MarketInfo(_instrument,MODE_STOPLEVEL); int order = OrderSend(_instrument, orderType, _amount, _rate, _slippage, _stop, _limit, _comment, _magicNumber); if (order == -1) { int error = GetLastError(); switch (error) { case ERR_TRADE_NOT_ALLOWED: errorMessage = "Trading is not allowed"; break; case 130: errorMessage = "Failed to create order: stoploss/takeprofit is too close"; break; default: errorMessage = "Failed to create order: " + IntegerToString(error); break; } } return order; } }; // Market order builder v 1.4 class MarketOrderBuilder { OrderSide _orderSide; string _instrument; double _amount; double _rate; int _slippage; double _stop; double _limit; int _magicNumber; string _comment; public: MarketOrderBuilder *SetSide(const OrderSide orderSide) { _orderSide = orderSide; return &this; } MarketOrderBuilder *SetInstrument(const string instrument) { _instrument = instrument; return &this; } MarketOrderBuilder *SetAmount(const double amount) { _amount = amount; return &this; } MarketOrderBuilder *SetSlippage(const int slippage) { _slippage = slippage; return &this; } MarketOrderBuilder *SetStopLoss(const double stop) { _stop = NormalizeDouble(stop, Digits); return &this; } MarketOrderBuilder *SetTakeProfit(const double limit) { _limit = NormalizeDouble(limit, Digits); return &this; } MarketOrderBuilder *SetMagicNumber(const int magicNumber) { _magicNumber = magicNumber; return &this; } MarketOrderBuilder *SetComment(const string comment) { _comment = comment; return &this; } int Execute(string &errorMessage) { int orderType = _orderSide == BuySide ? OP_BUY : OP_SELL; double minstoplevel = MarketInfo(_instrument, MODE_STOPLEVEL); double rate = _orderSide == BuySide ? MarketInfo(_instrument, MODE_ASK) : MarketInfo(_instrument, MODE_BID); int order = OrderSend(_instrument, orderType, _amount, rate, _slippage, _stop, _limit, _comment, _magicNumber); if (order == -1) { int error = GetLastError(); switch (error) { case ERR_NOT_ENOUGH_MONEY: errorMessage = "Not enought money"; return -1; case ERR_INVALID_TRADE_VOLUME: { double minVolume = SymbolInfoDouble(_instrument, SYMBOL_VOLUME_MIN); if (_amount < minVolume) { errorMessage = "Volume of the lot is too low: " + DoubleToStr(_amount) + " Min lot is: " + DoubleToStr(minVolume); return -1; } double maxVolume = SymbolInfoDouble(_instrument, SYMBOL_VOLUME_MAX); if (_amount > maxVolume) { errorMessage = "Volume of the lot is too high: " + DoubleToStr(_amount) + " Max lot is: " + DoubleToStr(maxVolume); return -1; } errorMessage = "Invalid volume: " + DoubleToStr(_amount); } return -1; case ERR_TRADE_NOT_ALLOWED: errorMessage = "Trading is not allowed"; return -1; case ERR_INVALID_STOPS: { double point = SymbolInfoDouble(_instrument, SYMBOL_POINT); int minStopDistancePoints = (int)SymbolInfoInteger(_instrument, SYMBOL_TRADE_STOPS_LEVEL); if (_stop != 0.0) { if (MathRound(MathAbs(rate - _stop) / point) < minStopDistancePoints) errorMessage = "Your stop loss level is too close. The minimal distance allowed is " + IntegerToString(minStopDistancePoints) + " points"; else errorMessage = "Invalid stop loss in the request"; } else if (_limit != 0.0) { if (MathRound(MathAbs(rate - _limit) / point) < minStopDistancePoints) errorMessage = "Your take profit level is too close. The minimal distance allowed is " + IntegerToString(minStopDistancePoints) + " points"; else errorMessage = "Invalid take profit in the request"; } else errorMessage = "Invalid take profit in the request"; } return -1; case ERR_INVALID_PRICE: errorMessage = "Invalid price"; return -1; default: errorMessage = "Failed to create order: " + IntegerToString(error); return -1; } } return order; } }; // Entry strategy v.1.2 interface IEntryStrategy { public: virtual int OpenPosition(const int period, OrderSide side, IMoneyManagementStrategy *moneyManagement, const string comment, double &stopLoss) = 0; virtual int Exit(const OrderSide side) = 0; }; class PendingEntryStrategy : public IEntryStrategy { string _symbol; int _magicMumber; int _slippagePoints; IStream *_longEntryPrice; IStream *_shortEntryPrice; public: PendingEntryStrategy(const string symbol, const int magicMumber, const int slippagePoints , IStream *longEntryPrice, IStream *shortEntryPrice) { _magicMumber = magicMumber; _slippagePoints = slippagePoints; _symbol = symbol; _longEntryPrice = longEntryPrice; _shortEntryPrice = shortEntryPrice; } ~PendingEntryStrategy() { delete _longEntryPrice; delete _shortEntryPrice; } int OpenPosition(const int period, OrderSide side, IMoneyManagementStrategy *moneyManagement, const string comment, double &stopLoss) { double entryPrice; if (!GetEntryPrice(period, side, entryPrice)) return -1; string error; double amount; double takeProfit; moneyManagement.Get(period, entryPrice, amount, stopLoss, takeProfit); if (amount == 0.0) return -1; OrderBuilder *orderBuilder = new OrderBuilder(); int order = orderBuilder .SetRate(entryPrice) .SetSide(side) .SetInstrument(_symbol) .SetAmount(amount) .SetSlippage(_slippagePoints) .SetMagicNumber(_magicMumber) .SetStopLoss(stopLoss) .SetTakeProfit(takeProfit) .SetComment(comment) .Execute(error); delete orderBuilder; if (order == -1) { Print("Failed to open position: " + error); } return order; } int Exit(const OrderSide side) { TradingCommands::DeleteOrders(_magicMumber); return 0; } private: bool GetEntryPrice(const int period, const OrderSide side, double &price) { if (side == BuySide) return _longEntryPrice.GetValue(period, price); return _shortEntryPrice.GetValue(period, price); } }; class MarketEntryStrategy : public IEntryStrategy { string _symbol; int _magicMumber; int _slippagePoints; public: MarketEntryStrategy(const string symbol, const int magicMumber, const int slippagePoints) { _magicMumber = magicMumber; _slippagePoints = slippagePoints; _symbol = symbol; } int OpenPosition(const int period, OrderSide side, IMoneyManagementStrategy *moneyManagement, const string comment, double &stopLoss) { double entryPrice = side == BuySide ? InstrumentInfo::GetAsk(_symbol) : InstrumentInfo::GetBid(_symbol); double amount; double takeProfit; moneyManagement.Get(period, entryPrice, amount, stopLoss, takeProfit); if (amount == 0.0) return -1; string error; MarketOrderBuilder *orderBuilder = new MarketOrderBuilder(); int order = orderBuilder .SetSide(side) .SetInstrument(_symbol) .SetAmount(amount) .SetSlippage(_slippagePoints) .SetMagicNumber(_magicMumber) .SetStopLoss(stopLoss) .SetTakeProfit(takeProfit) .SetComment(comment) .Execute(error); delete orderBuilder; if (order == -1) { Print("Failed to open position: " + error); } return order; } int Exit(const OrderSide side) { OrdersIterator toClose(); toClose.WhenSide(side).WhenMagicNumber(_magicMumber).WhenTrade(); return TradingCommands::CloseTrades(toClose, _slippagePoints); } }; // Mandatory closing v.1.0 interface IMandatoryClosingLogic { public: virtual void DoLogic() = 0; }; class NoMandatoryClosing : public IMandatoryClosingLogic { public: void DoLogic() { } }; class DoMandatoryClosing : public IMandatoryClosingLogic { int _magicNumber; int _slippagePoints; Signaler *_signaler; public: DoMandatoryClosing(const int magicNumber, Signaler *signaler, int slippagePoints) { _slippagePoints = slippagePoints; _magicNumber = magicNumber; _signaler = signaler; } void DoLogic() { OrdersIterator toClose(); toClose.WhenMagicNumber(_magicNumber).WhenTrade(); int positionsClosed = TradingCommands::CloseTrades(toClose, _slippagePoints); TradingCommands::DeleteOrders(_magicNumber); if (positionsClosed > 0) _signaler.SendNotifications("Mandatory closing"); } }; class TradeController { ENUM_TIMEFRAMES _timeframe; datetime _lastbartime; double _lastLot; IBreakevenLogic *_breakeven; ITrailingLogic *_trailing; Signaler *_signaler; datetime _lastBarDate; TradeCalculator *_calculator; TradingTime *_tradingTime; ICondition *_longCondition; ICondition *_shortCondition; ICondition *_exitAllCondition; ICondition *_exitLongCondition; ICondition *_exitShortCondition; IMoneyManagementStrategy *_longMoneyManagement; IMoneyManagementStrategy *_shortMoneyManagement; ICloseOnOppositeStrategy *_closeOnOpposite; #ifdef POSITION_CAP_FEATURE IPositionCapStrategy *_longPositionCap; IPositionCapStrategy *_shortPositionCap; #endif IEntryStrategy *_entryStrategy; IMandatoryClosingLogic *_mandatoryClosing; ICustomExitLogic *_customExit; string _algorithmId; public: TradeController(TradeCalculator *calculator, ENUM_TIMEFRAMES timeframe, Signaler *signaler, const string algorithmId = "") { _algorithmId = algorithmId; _customExit = NULL; #ifdef POSITION_CAP_FEATURE _longPositionCap = NULL; _shortPositionCap = NULL; #endif _closeOnOpposite = NULL; _longMoneyManagement = NULL; _shortMoneyManagement = NULL; _longCondition = NULL; _shortCondition = NULL; _calculator = calculator; _signaler = signaler; _timeframe = timeframe; _lastLot = lots_value; _exitAllCondition = NULL; _exitLongCondition = NULL; _exitShortCondition = NULL; _tradingTime = NULL; _mandatoryClosing = NULL; } ~TradeController() { delete _customExit; delete _mandatoryClosing; delete _entryStrategy; #ifdef POSITION_CAP_FEATURE delete _longPositionCap; delete _shortPositionCap; #endif delete _closeOnOpposite; delete _longMoneyManagement; delete _shortMoneyManagement; delete _exitAllCondition; delete _exitLongCondition; delete _exitShortCondition; delete _calculator; delete _signaler; delete _breakeven; delete _trailing; delete _longCondition; delete _shortCondition; delete _tradingTime; } void SetCustomExit(ICustomExitLogic *customExit) { _customExit = customExit; } void SetTradingTime(TradingTime *tradingTime) { _tradingTime = tradingTime; } void SetBreakeven(IBreakevenLogic *breakeven) { _breakeven = breakeven; } void SetTrailing(ITrailingLogic *trailing) { _trailing = trailing; } void SetLongCondition(ICondition *condition) { _longCondition = condition; } void SetShortCondition(ICondition *condition) { _shortCondition = condition; } void SetExitAllCondition(ICondition *condition) { _exitAllCondition = condition; } void SetExitLongCondition(ICondition *condition) { _exitLongCondition = condition; } void SetExitShortCondition(ICondition *condition) { _exitShortCondition = condition; } void SetLongMoneyManagement(IMoneyManagementStrategy *moneyManagement) { _longMoneyManagement = moneyManagement; } void SetShortMoneyManagement(IMoneyManagementStrategy *moneyManagement) { _shortMoneyManagement = moneyManagement; } void SetCloseOnOpposite(ICloseOnOppositeStrategy *closeOnOpposite) { _closeOnOpposite = closeOnOpposite; } #ifdef POSITION_CAP_FEATURE void SetLongPositionCap(IPositionCapStrategy *positionCap) { _longPositionCap = positionCap; } void SetShortPositionCap(IPositionCapStrategy *positionCap) { _shortPositionCap = positionCap; } #endif void SetEntryStrategy(IEntryStrategy *entryStrategy) { _entryStrategy = entryStrategy; } void SetMandatoryClosing(IMandatoryClosingLogic *mandatoryClosing) { _mandatoryClosing = mandatoryClosing; } void DoTrading() { #ifdef LIVE_TRADING int tradePeriod = 0; datetime current_time = iTime(_calculator.GetSymbol(), _timeframe, tradePeriod); #else int tradePeriod = 1; datetime current_time = iTime(_calculator.GetSymbol(), _timeframe, tradePeriod); #endif _breakeven.DoLogic(tradePeriod); _trailing.DoLogic(); #ifndef LIVE_TRADING if (_lastBarDate != current_time) _lastBarDate = current_time; else return; #endif _customExit.DoLogic(); bool exitAll = _exitAllCondition.IsPass(tradePeriod); if (exitAll || (_exitLongCondition.IsPass(tradePeriod) && !_exitLongCondition.IsPass(tradePeriod + 1))) { if (_entryStrategy.Exit(BuySide) > 0) _signaler.SendNotifications(EXIT_BUY_SIGNAL); } if (exitAll || (_exitShortCondition.IsPass(tradePeriod) && !_exitShortCondition.IsPass(tradePeriod + 1))) { if (_entryStrategy.Exit(SellSide) > 0) _signaler.SendNotifications(EXIT_SELL_SIGNAL); } if (_tradingTime != NULL && !_tradingTime.IsTradingTime(TimeCurrent())) { _mandatoryClosing.DoLogic(); return; } if (current_time == _lastbartime) return; if (_longCondition.IsPass(tradePeriod) && !_longCondition.IsPass(tradePeriod + 1)) { #ifdef POSITION_CAP_FEATURE if (_longPositionCap.IsLimitHit()) { _signaler.SendNotifications("Positions limit has been reached"); return; } #endif _closeOnOpposite.DoClose(BuySide); double stopLoss = 0.0; int order = _entryStrategy.OpenPosition(tradePeriod, BuySide, _longMoneyManagement, _algorithmId, stopLoss); if (order >= 0) { _lastbartime = current_time; _breakeven.CreateBreakeven(order, tradePeriod); _trailing.Create(order, (_calculator.GetAsk() - stopLoss) / _calculator.GetPipSize()); } _signaler.SendNotifications(ENTER_BUY_SIGNAL); } if (_shortCondition.IsPass(tradePeriod) && !_shortCondition.IsPass(tradePeriod + 1)) { #ifdef POSITION_CAP_FEATURE if (_shortPositionCap.IsLimitHit()) { _signaler.SendNotifications("Positions limit has been reached"); return; } #endif _closeOnOpposite.DoClose(SellSide); double stopLoss = 0.0; int order = _entryStrategy.OpenPosition(tradePeriod, SellSide, _shortMoneyManagement, _algorithmId, stopLoss); if (order >= 0) { _lastbartime = current_time; _breakeven.CreateBreakeven(order, tradePeriod); _trailing.Create(order, (stopLoss - _calculator.GetBid()) / _calculator.GetPipSize()); } _signaler.SendNotifications(ENTER_SELL_SIGNAL); } } private: }; TradeController *controllers[]; TradeController *CreateController(const string symbol, const ENUM_TIMEFRAMES timeframe, string &error) { TradingTime *tradingTime = new TradingTime(); if (!tradingTime.Init(start_time, stop_time, error)) { delete tradingTime; return NULL; } if (use_weekly_timing && !tradingTime.SetWeekTradingTime(week_start_day, week_start_time, week_stop_day, week_stop_time, error)) { delete tradingTime; return NULL; } TradeCalculator *tradeCalculator = TradeCalculator::Create(symbol); if (!tradeCalculator.IsLotsValid(lots_value, lots_type, error)) { delete tradeCalculator; delete tradingTime; return NULL; } Signaler *signaler = new Signaler(symbol, timeframe); TradeController *controller = new TradeController(tradeCalculator, timeframe, signaler); if (breakeven_type == StopLimitDoNotUse) controller.SetBreakeven(new DisabledBreakevenLogic()); else controller.SetBreakeven(new BreakevenLogic(breakeven_type, breakeven_value, breakeven_level, signaler)); if (trailing_type == TrailingDontUse) controller.SetTrailing(new DisabledTrailingLogic()); else controller.SetTrailing(new TrailingLogic(trailing_type, trailing_step, 0, timeframe, signaler)); controller.SetTradingTime(tradingTime); ICondition *longCondition = trading_side != ShortSideOnly ? (ICondition *)new LongCondition(symbol, timeframe) : (ICondition *)new DisabledCondition(); ICondition *shortCondition = trading_side != LongSideOnly ? (ICondition *)new ShortCondition(symbol, timeframe) : (ICondition *)new DisabledCondition(); IMoneyManagementStrategy *longMoneyManagement = new LongMoneyManagementStrategy(tradeCalculator, lots_type, lots_value, stop_loss_type, stop_loss_value, take_profit_type, take_profit_value); IMoneyManagementStrategy *shortMoneyManagement = new ShortMoneyManagementStrategy(tradeCalculator, lots_type, lots_value, stop_loss_type, stop_loss_value, take_profit_type, take_profit_value); ICondition *exitLongCondition = new ExitLongCondition(symbol, timeframe); ICondition *exitShortCondition = new ExitShortCondition(symbol, timeframe); switch (logic_direction) { case DirectLogic: controller.SetLongCondition(longCondition); controller.SetShortCondition(shortCondition); controller.SetLongMoneyManagement(longMoneyManagement); controller.SetShortMoneyManagement(shortMoneyManagement); controller.SetExitLongCondition(exitLongCondition); controller.SetExitShortCondition(exitShortCondition); break; case ReversalLogic: controller.SetLongCondition(shortCondition); controller.SetShortCondition(longCondition); controller.SetLongMoneyManagement(shortMoneyManagement); controller.SetShortMoneyManagement(longMoneyManagement); controller.SetExitLongCondition(exitShortCondition); controller.SetExitShortCondition(exitLongCondition); break; } controller.SetExitAllCondition(new DisabledCondition()); if (close_on_opposite) controller.SetCloseOnOpposite(new DoCloseOnOppositeStrategy(magic_number, slippage_points)); else controller.SetCloseOnOpposite(new DontCloseOnOppositeStrategy()); #ifdef POSITION_CAP_FEATURE if (position_cap) { controller.SetLongPositionCap(new PositionCapStrategy(BuySide, magic_number, no_of_buy_position, no_of_positions, symbol)); controller.SetShortPositionCap(new PositionCapStrategy(SellSide, magic_number, no_of_sell_position, no_of_positions, symbol)); } else { controller.SetLongPositionCap(new NoPositionCapStrategy()); controller.SetShortPositionCap(new NoPositionCapStrategy()); } #endif controller.SetEntryStrategy(new MarketEntryStrategy(symbol, magic_number, slippage_points)); controller.SetCustomExit(new CustomExitLogic()); if (mandatory_closing) controller.SetMandatoryClosing(new DoMandatoryClosing(magic_number, signaler, slippage_points)); else controller.SetMandatoryClosing(new NoMandatoryClosing()); return controller; } int OnInit() { double temp = iCustom(NULL, 0, "sideways_bias", 0, 0); if (GetLastError() == ERR_INDICATOR_CANNOT_LOAD) { Alert("Please, install the 'sideways_bias' indicator"); return INIT_FAILED; } if (!IsDllsAllowed() && Advanced_Alert) { Print("Error: Dll calls must be allowed!"); return INIT_FAILED; } string error; TradeController *controller = CreateController(_Symbol, (ENUM_TIMEFRAMES)_Period, error); if (controller == NULL) { Print(error); return INIT_FAILED; } int controllersCount = 0; ArrayResize(controllers, controllersCount + 1); controllers[controllersCount++] = controller; return INIT_SUCCEEDED; } void OnDeinit(const int reason) { int i_count = ArraySize(controllers); for (int i = 0; i < i_count; ++i) { delete controllers[i]; } } void OnTick() { int i_count = ArraySize(controllers); for (int i = 0; i < i_count; ++i) { controllers[i].DoTrading(); } }