Open Close Cross Strategy R5.1 revised by JustUncleL

#property version "1.0.1"

#property description "Open Close Cross Strategy R5.1 revised by JustUncleL"
#property strict

#property indicator_buffers 14
#property indicator_chart_window

#property indicator_color3  clrGreen
#property indicator_width3  2

#property indicator_color4  clrRed
#property indicator_width4  2

#property indicator_color5  clrGreen
#property indicator_width5  2

#property indicator_color6  clrRed
#property indicator_width6  2

enum AveragesMethod
{
   SMA = MODE_SMA, // SMA
   EMA = MODE_EMA, // EMA
   SMMA = MODE_SMMA, // SMMA
   LWMA = MODE_LWMA, // LWMA
   WMA,
   SineWMA,
   TriMA,
   LSMA,
   HMA,
   ZeroLagEMA,
   DEMA,
   T3MA,
   ITrend,
   Median,
   GeoMean,
   REMA,
   ILRS,
   IE2,
   TriMAgen,
   JSmooth
};

enum TradingDirection
{
    Buy,
    Sell,
    Both
};

enum StopLimitType
{
    StopLimitPercent, // %
    StopLimitPips, // Pips
    StopLimitDollar // $
};

enum PositionSizeType
{
    PositionSizeAmount, // $
    PositionSizeContract, // In contracts
    PositionSizeEquity // % of equity
};

enum PositionDirection
{
    DirectLogic, // Direct
    ReversalLogic // Reversal
};

extern bool useRes = true; // Use Alternate Resolution?
extern int intRes = 3; // Multiplier for Alernate Resolution
extern AveragesMethod basisType = SMMA; // MA Type
extern int basisLen = 8; // MA Period

extern bool scolor = false; // Show coloured Bars to indicate Trend?
extern color UpCandleColor = clrGreen; // Up bars color
extern color DownCandleColor = clrRed; // Down bars color

extern bool AllowTrading = true; // Allow trading?
extern TradingDirection TradeType = Both; // What trades should be taken
extern double Lots            = 0.1; // Position size
extern PositionSizeType LotsType = PositionSizeContract; // Position size type
extern int Slippage           = 3;
extern bool close_on_opposite = true; // Close on opposite
extern bool SetStop           = true; // Set stop loss?
extern double Stop            = 10; // Stop loss value
extern StopLimitType StopType = StopLimitPips; // Stop loss type
extern bool SetLimit          = true; // Set take profit?
extern double Limit           = 10; // Take profit value
extern StopLimitType LimitType = StopLimitPips; // Take profit type
extern bool MoveToBreakeven = false; // Move to breakeven
extern double BreakevenTrigger = 10; // Trigger for the breakeven
extern StopLimitType BreakevenTriggerType = StopLimitPips; // Trigger type for the breakeven
extern int MagicNumber        = 42; // Magic number
extern PositionDirection LogicType = DirectLogic; // Logic type

class CandleStreams
{
public:
   double OpenStream[];
   double CloseStream[];
   double HighStream[];
   double LowStream[];

   void Clear(const int index)
   {
      OpenStream[index] = EMPTY_VALUE;
      CloseStream[index] = EMPTY_VALUE;
      HighStream[index] = EMPTY_VALUE;
      LowStream[index] = EMPTY_VALUE;
   }

   int RegisterStreams(const int id, const color clr)
   {
      SetIndexStyle(id + 0, DRAW_HISTOGRAM, STYLE_SOLID, 3, clr);
      SetIndexBuffer(id + 0, OpenStream);
      SetIndexStyle(id + 1, DRAW_HISTOGRAM, STYLE_SOLID, 3, clr);
      SetIndexBuffer(id + 1, CloseStream);
      SetIndexStyle(id + 2, DRAW_HISTOGRAM, STYLE_SOLID, 1, clr);
      SetIndexBuffer(id + 2, HighStream);
      SetIndexStyle(id + 3, DRAW_HISTOGRAM, STYLE_SOLID, 3, clr);
      SetIndexBuffer(id + 3, LowStream);
      return id + 4;
   }

   void Set(const int index, const double open, const double high, const double low, const double close)
   {
      OpenStream[index] = open;
      HighStream[index] = high;
      LowStream[index] = low;
      CloseStream[index] = close;
   }
};

CandleStreams upCandles;
CandleStreams downCandles;

double closeSeries[], openSeries[];
double closeSeriesUp[], closeSeriesDown[];
double openSeriesUp[], openSeriesDown[];
ENUM_TIMEFRAMES btf = PERIOD_CURRENT;

ENUM_TIMEFRAMES RoundPeriod(const int period)
{
   if (period < PERIOD_M5)
      return PERIOD_M1;
   if (period < PERIOD_M15)
      return PERIOD_M5;
   if (period < PERIOD_M30)
      return PERIOD_M15;
   if (period < PERIOD_H1)
      return PERIOD_M30;
   if (period < PERIOD_H4)
      return PERIOD_H1;
   if (period < PERIOD_D1)
      return PERIOD_H4;
   if (period < PERIOD_W1)
      return PERIOD_D1;
   if (period < PERIOD_MN1)
      return PERIOD_W1;
   return PERIOD_MN1;
}

int OnInit()
{
      // код доступен только после оплаты
   }

void OnDeinit(const int reason)
{
   delete tradingLogic;
}

int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[])
{
      // код доступен только после оплаты
   }

class BreakevenController
{
    int _order;
    bool _finished;
    double _trigger;
    double _target;
public:
    BreakevenController()
    {
        _finished = false;
    }

    bool SetOrder(const int order, const double trigger, const double target)
    {
        if (!_finished)
        {
            return false;
        }
        _finished = false;
        _trigger = trigger;
        _target = target;
        _order = order;
        return true;
    }

    void DoLogic()
    {
        if (_finished || !OrderSelect(_order, SELECT_BY_TICKET, MODE_TRADES))
        {
            _finished = true;
            return;
        }

        int type = OrderType();
        if (type == OP_BUY)
        {
            if (Ask >= _trigger)
            {
                int res = OrderModify(OrderTicket(), OrderOpenPrice(), _target, OrderTakeProfit(), 0, CLR_NONE);
                _finished = true;
            }
        } 
        else if (type == OP_SELL) 
        {
            if (Bid < _trigger) 
            {
                int res = OrderModify(OrderTicket(), OrderOpenPrice(), _target, OrderTakeProfit(), 0, CLR_NONE);
                _finished = true;
            }
        } 
    }
};

bool crossOver(const double &left[], const double &right[], const int period)
{
   return left[period] > right[period] && left[period + 1] < right[period + 1];
}

bool crossUnder(const double &left[], const double &right[], const int period)
{
   return left[period] < right[period] && left[period + 1] > right[period + 1];
}

class TradeController
{
   bool IsBuyCondition()
   {
      if ((TradeType == Sell && LogicType == DirectLogic)
         || (TradeType == Buy && LogicType == ReversalLogic))
      {
         return false;
      }
      return crossOver(closeSeries, openSeries, 0);
   }

  

Показано первые 50% кода (символов: 12687)