Trading System Using Relative Strength-Part 2

Quoting smjones

Disliked

Any time you are assigning a value to a array for an index. The reason is MT4 returns the value of your installed ram as the empty set. If you do not want a variable to contain a value, use 0 or use NULL

Ignored

//+------------------------------------------------------------------+
#define SIGNAL_NONE 0
#define SIGNAL_BUY   1
#define SIGNAL_SELL  2
#define SIGNAL_CLOSEBUY 3
#define SIGNAL_CLOSESELL 4

#property copyright "Ronald Raygun"

extern string Remark1 = "== Main Settings ==";
extern int MagicNumber = 0;
extern bool SignalsOnly = False;
extern bool Alerts = False;
extern bool SignalMail = False;
extern bool PlaySounds = False;
bool EachTickMode = True;
extern bool CloseOnOppositeSignal = True;
extern double Lots = 0;
extern bool MoneyManagement = False;
extern int Risk = 0;
extern int Slippage = 5;
extern  bool UseStopLoss = True;
extern int StopLoss = 100;
extern bool UseTakeProfit = False;
extern int TakeProfit = 60;
extern bool UseTrailingStop = False;
extern int TrailingStop = 30;
extern bool MoveStopOnce = False;
extern int MoveStopWhenPrice = 50;
extern int MoveStopTo = 1;
extern string Remark2 = "";
extern string Remark3 = "== CCFp Settings ==";
extern int MA_Method = 3;
extern int Price = 6;
extern int Fast = 3;
extern int Slow = 5;
extern bool TradeHighestOnly = False;
extern bool IdentifyHighestPair = False;
extern color Color = Blue;
extern int MinutesDelayStart = 5;
extern int MinutesDelayEnd = 10;
extern int TradeLevel = 4;
extern bool TradeReversals = True;
extern bool UseCurrent = False;


//Version 2.01

int BarCount;
int GlobalCount;
double EACount = 0;

int Current;
bool TickCheck = False;
//+------------------------------------------------------------------+
//| expert initialization function                                   |
//+------------------------------------------------------------------+
int init() {
   BarCount = Bars;

   if (UseCurrent) Current = 0; else Current = 1;
   
   if(GlobalVariableCheck("RelativeStrengthCount")) {
      EACount = GlobalVariableGet("RelativeStrengthCount") + 1;
      GlobalVariableSet("RelativeStrengthCount", EACount);
      }
      else
      GlobalVariableSet("RelativeStrengthCount", 1);



   return(0);
}
//+------------------------------------------------------------------+
//| expert deinitialization function                                 |
//+------------------------------------------------------------------+
int deinit() {

   if(GlobalVariableCheck("RelativeStrengthCount")) {
      EACount = GlobalVariableGet("RelativeStrengthCount") - 1;
      if(EACount <= 0) GlobalVariableDel("RelativeStrengthCount");
         else GlobalVariableSet("RelativeStrengthCount", EACount);
      }

   return(0);
}
//+------------------------------------------------------------------+
//| expert start function                                            |
//+------------------------------------------------------------------+
int start() 


{
   int Order = SIGNAL_NONE;
   int Total, Ticket;
   double StopLossLevel, TakeProfitLevel;



   if (EachTickMode && Bars != BarCount) TickCheck = False;
   Total = OrdersTotal();
   Order = SIGNAL_NONE;

//Money Management sequence
 if (MoneyManagement)
   {
      if (Risk<1 || Risk>100)
      {
         Comment("Invalid Risk Value.");
         return(0);
      }
      else
      {
         Lots=MathFloor((AccountFreeMargin()*AccountLeverage()*Risk*Point*100)/(Ask*MarketInfo(Symbol(),MODE_LOTSIZE)*MarketInfo(Symbol(),MODE_MINLOT)))*MarketInfo(Symbol(),MODE_MINLOT);
      }
   }

   //+------------------------------------------------------------------+
   //| Variable Begin                                                   |
   //+------------------------------------------------------------------+
   
//Reset GlobalCount
if(GlobalCount != Bars) {
GlobalVariableSet("TotalChangeRank", 0);
GlobalCount = Bars;
}



//EACounts
double EACounts = 0;
if(GlobalVariableCheck("RelativeStrengthCount")) EACounts = GlobalVariableGet("RelativeStrengthCount");
   else EACounts = 1;

//Determine Base and Counter Currency
string BaseCurrency = StringSubstr(Symbol(), 0, 3);
string CounterCurrency = StringSubstr(Symbol(), 3, 3);

//Establish Individual Currencies
double USD = iCustom(NULL, 0, "CCFp", MA_Method, Price, Fast, Slow, True, True, True, True, True, True, True, True, Black, Black, Black, Black, Black, Black, Black, Black, 2, 0, 0, 0, Current + 0);
double USD1 = iCustom(NULL, 0, "CCFp", MA_Method, Price, Fast, Slow, True, True, True, True, True, True, True, True, Black, Black, Black, Black, Black, Black, Black, Black, 2, 0, 0, 0, Current + 1);

double EUR = iCustom(NULL, 0, "CCFp", MA_Method, Price, Fast, Slow, True, True, True, True, True, True, True, True, Black, Black, Black, Black, Black, Black, Black, Black, 2, 0, 0, 1, Current + 0);
double EUR1 = iCustom(NULL, 0, "CCFp", MA_Method, Price, Fast, Slow, True, True, True, True, True, True, True, True, Black, Black, Black, Black, Black, Black, Black, Black, 2, 0, 0, 1, Current + 1);

double GBP = iCustom(NULL, 0, "CCFp", MA_Method, Price, Fast, Slow, True, True, True, True, True, True, True, True, Black, Black, Black, Black, Black, Black, Black, Black, 2, 0, 0, 2, Current + 0);
double GBP1 = iCustom(NULL, 0, "CCFp", MA_Method, Price, Fast, Slow, True, True, True, True, True, True, True, True, Black, Black, Black, Black, Black, Black, Black, Black, 2, 0, 0, 2, Current + 1);

double CHF = iCustom(NULL, 0, "CCFp", MA_Method, Price, Fast, Slow, True, True, True, True, True, True, True, True, Black, Black, Black, Black, Black, Black, Black, Black, 2, 0, 0, 3, Current + 0);
double CHF1 = iCustom(NULL, 0, "CCFp", MA_Method, Price, Fast, Slow, True, True, True, True, True, True, True, True, Black, Black, Black, Black, Black, Black, Black, Black, 2, 0, 0, 3, Current + 1);

double JPY = iCustom(NULL, 0, "CCFp", MA_Method, Price, Fast, Slow, True, True, True, True, True, True, True, True, Black, Black, Black, Black, Black, Black, Black, Black, 2, 0, 0, 4, Current + 0);
double JPY1 = iCustom(NULL, 0, "CCFp", MA_Method, Price, Fast, Slow, True, True, True, True, True, True, True, True, Black, Black, Black, Black, Black, Black, Black, Black, 2, 0, 0, 4, Current + 1);

double AUD = iCustom(NULL, 0, "CCFp", MA_Method, Price, Fast, Slow, True, True, True, True, True, True, True, True, Black, Black, Black, Black, Black, Black, Black, Black, 2, 0, 0, 5, Current + 0);
double AUD1 = iCustom(NULL, 0, "CCFp", MA_Method, Price, Fast, Slow, True, True, True, True, True, True, True, True, Black, Black, Black, Black, Black, Black, Black, Black, 2, 0, 0, 5, Current + 1);

double CAD = iCustom(NULL, 0, "CCFp", MA_Method, Price, Fast, Slow, True, True, True, True, True, True, True, True, Black, Black, Black, Black, Black, Black, Black, Black, 2, 0, 0, 6, Current + 0);
double CAD1 = iCustom(NULL, 0, "CCFp", MA_Method, Price, Fast, Slow, True, True, True, True, True, True, True, True, Black, Black, Black, Black, Black, Black, Black, Black, 2, 0, 0, 6, Current + 1);

double NZD = iCustom(NULL, 0, "CCFp", MA_Method, Price, Fast, Slow, True, True, True, True, True, True, True, True, Black, Black, Black, Black, Black, Black, Black, Black, 2, 0, 0, 7, Current + 0);
double NZD1 = iCustom(NULL, 0, "CCFp", MA_Method, Price, Fast, Slow, True, True, True, True, True, True, True, True, Black, Black, Black, Black, Black, Black, Black, Black, 2, 0, 0, 7, Current + 1);

//Match Base Currency
double Base = 0;
double Base1 = 0;

if(BaseCurrency == "USD") {
   Base = USD;
   Base1 = USD1;
   }

if(BaseCurrency == "EUR") {
   Base = EUR;
   Base1 = EUR1;
   }
   
if(BaseCurrency == "GBP") {
   Base = GBP;
   Base1 = GBP1;
   }

if(BaseCurrency == "CHF") {
   Base = CHF;
   Base1 = CHF1;
   }
   
if(BaseCurrency == "JPY") {
   Base = JPY;
   Base1 = JPY1;
   }
   
if(BaseCurrency == "AUD") {
   Base = AUD;
   Base1 = AUD1;
   }
   
if(BaseCurrency == "CAD") {
   Base = CAD;
   Base1 = CAD1;
   }
   
if(BaseCurrency == "NZD") {
   Base = NZD;
   Base1 = NZD1;
   }   
                  

//Match Counter Currency
double Counter = 0;
double Counter1 = 0;

if(CounterCurrency == "USD") {
   Counter = USD;
   Counter1 = USD1;
   }

if(CounterCurrency == "EUR") {
   Counter = EUR;
   Counter1 = EUR1;
   }
   
if(CounterCurrency == "GBP") {
   Counter = GBP;
   Counter1 = GBP1;
   }

if(CounterCurrency == "CHF") {
   Counter = CHF;
   Counter1 = CHF1;
   }
   
if(CounterCurrency == "JPY") {
   Counter = JPY;
   Counter1 = JPY1;
   }
   
if(CounterCurrency == "AUD") {
   Counter = AUD;
   Counter1 = AUD1;
   }
   
if(CounterCurrency == "CAD") {
   Counter = CAD;
   Counter1 = CAD1;
   }
   
if(CounterCurrency == "NZD") {
   Counter = NZD;
   Counter1 = NZD1;
   }   
      
//Determine Change
double BaseChange = Base - Base1;
double BaseScore1 = Lookup(NormalizeDouble((BaseChange * 10000), 0));
int BaseScore = MathAbs(BaseScore1);
double CounterChange = Counter - Counter1;      
double CounterScore1 = Lookup(NormalizeDouble((CounterChange * 10000), 0));
int CounterScore = MathAbs(CounterScore1);
double TotalChange = MathAbs(BaseChange - CounterChange);
int TotalScore = MathAbs(BaseScore1 - CounterScore1);      
      
//Establish Direction
string BaseDirection = "None";
if(BaseChange > 0) BaseDirection = "Long";
if(BaseChange < 0) BaseDirection = "Short";

string CounterDirection = "None";
if(CounterChange > 0) CounterDirection = "Long";
if(CounterChange < 0) CounterDirection = "Short";

//Determine Trade Type
string ReversePair = "Regular Trade";
if(TradeReversals && (BaseScore < TradeLevel || CounterScore < TradeLevel)) ReversePair = "Reverse Trade";

//Determine Rank
double TotalChangeCheck = 0;
if(GlobalVariableCheck("TotalChangeRank")) {
   TotalChangeCheck = GlobalVariableGet("TotalChangeRank");
   if(TotalScore > TotalChangeCheck) GlobalVariableSet("TotalChangeRank", TotalScore);
   }
   else {
   GlobalVariableSet("TotalChangeRank", TotalScore);
   TotalChangeCheck = GlobalVariableGet("TotalChangeRank");
   }
string CurrentRank = "Not Highest";
if(TradeHighestOnly && TotalChangeCheck == TotalChange) CurrentRank = "Highest";
if(!TradeHighestOnly) CurrentRank = "Not Used";

//Notification
if(CurrentRank == "Highest" && IdentifyHighestPair) {
if(ObjectFind("Notification") < 0) {
   ObjectCreate("Notification", OBJ_RECTANGLE, 0, TimeCurrent(), Close[0] + 100000, iTime(NULL, 0, Bars), Close[0] - 100000);
   ObjectSet("Notification", OBJPROP_COLOR, Color);
   }
}
if(CurrentRank != "Highest") {
   ObjectDelete("Notification");
}    
 



//Time Delay
string TimeDelay = "Outside Trading Times";
datetime BarOpen = Time[0];
datetime TradeStart = BarOpen + (MinutesDelayStart * 60);
datetime TradeEnd = BarOpen + (MinutesDelayEnd * 60);
if(TimeCurrent() >= TradeStart && TimeCurrent() < TradeEnd) TimeDelay = "Inside Trading Times";

string TradeTrigger = "None";
string NextTrade = "None";
if(CurrentRank != "Not Highest" && BaseDirection == "Long" && CounterDirection == "Short") {
   if(ReversePair == "Regular Trade") {
   if(TimeDelay == "Inside Trading Times") {TradeTrigger = "Open Long";}
   NextTrade = "Open Long";
   }
   if(ReversePair == "Reverse Trade") {
   if(TimeDelay == "Inside Trading Times") {TradeTrigger = "Open Short";}
   NextTrade = "Open Short";
   }
}
   
if(CurrentRank != "Not Highest" && BaseDirection == "Short" && CounterDirection == "Long") {
   if(ReversePair == "Regular Trade") {
   if(TimeDelay == "Inside Trading Times") TradeTrigger = "Open Short";
   NextTrade = "Open Short";
   }
   if(ReversePair == "Reverse Trade") {
   if(TimeDelay == "Inside Trading Times") TradeTrigger = "Open Long";
   NextTrade = "Open Long";
   }
}



Comment("EA Count: ", EACounts, "\n",
        "Trading Times: ", TimeDelay, "\n",
        "Current Rank: ", CurrentRank, "\n",
        "Base Currency: ", BaseCurrency, "\n",
        "Counter Currency: ", CounterCurrency, "\n",
        "Base Strength: ", BaseDirection, "\n",
        "Counter Strength: ", CounterDirection, "\n",
        "Base Change: ", BaseScore, ". Raw Values: ", NormalizeDouble((BaseChange * 10000), 0), ". Initial Change ", BaseChange, "\n",
        "Counter Change: ", CounterScore, ". Raw Values: ", NormalizeDouble((CounterChange * 10000), 0), ". Initial Change ", CounterChange, "\n",
        "Total Change: ", TotalScore, "\n",
        "Trade Level: ", TradeLevel, "\n",
        "Trade Type: ", ReversePair, "\n",
        "Next Trade: ", NextTrade, "\n",
        "Trade Trigger: ", TradeTrigger);
        
        
        



   //+------------------------------------------------------------------+
   //| Variable End                                                     |
   //+------------------------------------------------------------------+

   //Check position
   bool IsTrade = False;

   for (int i = 0; i < Total; i ++) {
      OrderSelect(i, SELECT_BY_POS, MODE_TRADES);
      if(OrderType() <= OP_SELL &&  OrderSymbol() == Symbol() && OrderMagicNumber() == MagicNumber) {
         IsTrade = True;
         if(OrderType() == OP_BUY) {
         
            
            //Close

            //+------------------------------------------------------------------+
            //| Signal Begin(Exit Buy)                                           |
            //+------------------------------------------------------------------+

if(CloseOnOppositeSignal && TradeTrigger == "Open Short") Order = SIGNAL_CLOSEBUY;  

            //+------------------------------------------------------------------+
            //| Signal End(Exit Buy)                                             |
            //+------------------------------------------------------------------+

            if (Order == SIGNAL_CLOSEBUY && ((EachTickMode && !TickCheck) || (!EachTickMode && (Bars != BarCount)))) {
               OrderClose(OrderTicket(), OrderLots(), Bid, Slippage, MediumSeaGreen);
               if (SignalMail) SendMail("[Signal Alert]", "[" + Symbol() + "] " + DoubleToStr(Bid, Digits) + " Close Buy");
               if (!EachTickMode) BarCount = Bars;
               IsTrade = False;
               continue;
            }
            //MoveOnce
            if(MoveStopOnce && MoveStopWhenPrice > 0) {
               if(Bid - OrderOpenPrice() >= Point * MoveStopWhenPrice) {
                  if(OrderStopLoss() < OrderOpenPrice() + Point * MoveStopTo) {
                  OrderModify(OrderTicket(),OrderOpenPrice(), OrderOpenPrice() + Point * MoveStopTo, OrderTakeProfit(), 0, Red);
                     if (!EachTickMode) BarCount = Bars;
                     continue;
                  }
               }
            }
            //Trailing stop
            if(UseTrailingStop && TrailingStop > 0) {                 
               if(Bid - OrderOpenPrice() > Point * TrailingStop) {
                  if(OrderStopLoss() < Bid - Point * TrailingStop) {
                     OrderModify(OrderTicket(), OrderOpenPrice(), Bid - Point * TrailingStop, OrderTakeProfit(), 0, MediumSeaGreen);
                     if (!EachTickMode) BarCount = Bars;
                     continue;
                  }
               }
            }
         } else {
        
            //Close

            //+------------------------------------------------------------------+
            //| Signal Begin(Exit Sell)                                          |
            //+------------------------------------------------------------------+

if(CloseOnOppositeSignal && TradeTrigger == "Open Long") Order = SIGNAL_CLOSESELL;  

            //+------------------------------------------------------------------+
            //| Signal End(Exit Sell)                                            |
            //+------------------------------------------------------------------+

            if (Order == SIGNAL_CLOSESELL && ((EachTickMode && !TickCheck) || (!EachTickMode && (Bars != BarCount)))) {
               OrderClose(OrderTicket(), OrderLots(), Ask, Slippage, DarkOrange);
               if (SignalMail) SendMail("[Signal Alert]", "[" + Symbol() + "] " + DoubleToStr(Ask, Digits) + " Close Sell");
               if (!EachTickMode) BarCount = Bars;
               IsTrade = False;
               continue;
            }
            //MoveOnce
            if(MoveStopOnce && MoveStopWhenPrice > 0) {
               if(OrderOpenPrice() - Ask >= Point * MoveStopWhenPrice) {
                  if(OrderStopLoss() > OrderOpenPrice() - Point * MoveStopTo) {
                  OrderModify(OrderTicket(),OrderOpenPrice(), OrderOpenPrice() - Point * MoveStopTo, OrderTakeProfit(), 0, Red);
                     if (!EachTickMode) BarCount = Bars;
                     continue;
                  }
               }
            }
            //Trailing stop
            if(UseTrailingStop && TrailingStop > 0) {                 
               if((OrderOpenPrice() - Ask) > (Point * TrailingStop)) {
                  if((OrderStopLoss() > (Ask + Point * TrailingStop)) || (OrderStopLoss() == 0)) {
                     OrderModify(OrderTicket(), OrderOpenPrice(), Ask + Point * TrailingStop, OrderTakeProfit(), 0, DarkOrange);
                     if (!EachTickMode) BarCount = Bars;
                     continue;
                  }
               }
            }
         }
      }
   }

   //+------------------------------------------------------------------+
   //| Signal Begin(Entry)                                              |
   //+------------------------------------------------------------------+

if(TradeTrigger == "Open Long") Order = SIGNAL_BUY;
if(TradeTrigger == "Open Short") Order = SIGNAL_SELL;

   //+------------------------------------------------------------------+
   //| Signal End                                                       |
   //+------------------------------------------------------------------+

   //Buy
   if (Order == SIGNAL_BUY && ((EachTickMode && !TickCheck) || (!EachTickMode && (Bars != BarCount)))) {
      if(SignalsOnly) {
         if (SignalMail) SendMail("[Signal Alert]", "[" + Symbol() + "] " + DoubleToStr(Ask, Digits) + "Buy Signal");
         if (Alerts) Alert("[" + Symbol() + "] " + DoubleToStr(Ask, Digits) + "Buy Signal");
         if (PlaySounds) PlaySound("alert.wav");
     
      }
      
      if(!IsTrade && !SignalsOnly) {
         //Check free margin
         if (AccountFreeMargin() < (1000 * Lots)) {
            Print("We have no money. Free Margin = ", AccountFreeMargin());
            return(0);
         }

         if (UseStopLoss) StopLossLevel = Ask - StopLoss * Point; else StopLossLevel = 0.0;
         if (UseTakeProfit) TakeProfitLevel = Ask + TakeProfit * Point; else TakeProfitLevel = 0.0;

         Ticket = OrderSend(Symbol(), OP_BUY, Lots, Ask, Slippage, StopLossLevel, TakeProfitLevel, "Buy(#" + MagicNumber + ")", MagicNumber, 0, DodgerBlue);
         if(Ticket > 0) {
            if (OrderSelect(Ticket, SELECT_BY_TICKET, MODE_TRADES)) {
                Print("BUY order opened : ", OrderOpenPrice());
                if (SignalMail) SendMail("[Signal Alert]", "[" + Symbol() + "] " + DoubleToStr(Ask, Digits) + "Buy Signal");
                   if (Alerts) Alert("[" + Symbol() + "] " + DoubleToStr(Ask, Digits) + "Buy Signal");
                if (PlaySounds) PlaySound("alert.wav");
            } else {
                Print("Error opening BUY order : ", GetLastError());
            }
         }
         if (EachTickMode) TickCheck = True;
         if (!EachTickMode) BarCount = Bars;
         return(0);
      }
   }

   //Sell
   if (Order == SIGNAL_SELL && ((EachTickMode && !TickCheck) || (!EachTickMode && (Bars != BarCount)))) {
      if(SignalsOnly) {
          if (SignalMail) SendMail("[Signal Alert]", "[" + Symbol() + "] " + DoubleToStr(Bid, Digits) + "Sell Signal");
          if (Alerts) Alert("[" + Symbol() + "] " + DoubleToStr(Bid, Digits) + "Sell Signal");
          if (PlaySounds) PlaySound("alert.wav");
         }
      if(!IsTrade && !SignalsOnly) {
         //Check free margin
         if (AccountFreeMargin() < (1000 * Lots)) {
            Print("We have no money. Free Margin = ", AccountFreeMargin());
            return(0);
         }

         if (UseStopLoss) StopLossLevel = Bid + StopLoss * Point; else StopLossLevel = 0.0;
         if (UseTakeProfit) TakeProfitLevel = Bid - TakeProfit * Point; else TakeProfitLevel = 0.0;

         Ticket = OrderSend(Symbol(), OP_SELL, Lots, Bid, Slippage, StopLossLevel, TakeProfitLevel, "Sell(#" + MagicNumber + ")", MagicNumber, 0, DeepPink);
         if(Ticket > 0) {
            if (OrderSelect(Ticket, SELECT_BY_TICKET, MODE_TRADES)) {
                Print("SELL order opened : ", OrderOpenPrice());
                if (SignalMail) SendMail("[Signal Alert]", "[" + Symbol() + "] " + DoubleToStr(Bid, Digits) + "Sell Signal");
                   if (Alerts) Alert("[" + Symbol() + "] " + DoubleToStr(Bid, Digits) + "Sell Signal");
                if (PlaySounds) PlaySound("alert.wav");
            } else {
                Print("Error opening SELL order : ", GetLastError());
            }
         }
         if (EachTickMode) TickCheck = True;
         if (!EachTickMode) BarCount = Bars;
         return(0);
      }
   }

   if (!EachTickMode) BarCount = Bars;

   return(0);
}


int Lookup(double ratio)
{
int aTable[19] = {-90,-80,-70,-60,-50,-40,-30,-20,-10,0,10,20,30,40,50,60,70,80,90};
int index;

if (ratio <= aTable[0]) index = -10;
else if (ratio <= aTable[1]) index = -9;
else if (ratio <= aTable[2]) index = -8;
else if (ratio <= aTable[3]) index = -7;
else if (ratio <= aTable[4]) index = -6;
else if (ratio <= aTable[5]) index = -5;
else if (ratio <= aTable[6]) index = -4;
else if (ratio <= aTable[7]) index = -3;
else if (ratio <= aTable[8]) index = -2;
else if (ratio <= aTable[9]) index = -1;
else if (ratio <= aTable[10]) index = 1;
else if (ratio <= aTable[11]) index = 2;
else if (ratio <= aTable[12]) index = 3;
else if (ratio <= aTable[13]) index = 4;
else if (ratio <= aTable[14]) index = 5;
else if (ratio <= aTable[15]) index = 6;
else if (ratio <= aTable[16]) index = 7;
else if (ratio <= aTable[17]) index = 8;
else if (ratio <= aTable[18]) index = 9;
else index = 10;

return(index);
}

//+------------------------------------------------------------------+
//|                                                         CCFp.mq4 |
//|                                              [email protected] |
//|              http://onix-trade.net/forum/index.php?showtopic=107 |
//+------------------------------------------------------------------+
#property copyright "[email protected]"
#property link      "http://onix-trade.net/forum/index.php?showtopic=107"
//----
string Indicator_Name = "CCFp:";
int Objs = 0;
//----
#property indicator_separate_window
#property indicator_buffers 8
extern int MA_Method = 3;
extern int Price = 6;
extern int Fast = 3;
extern int Slow = 5;
extern bool USD = 1;
extern bool EUR = 1;
extern bool GBP = 1;
extern bool CHF = 1;
extern bool JPY = 1;
extern bool AUD = 1;
extern bool CAD = 1;
extern bool NZD = 1;
extern color Color_USD = Green;
extern color Color_EUR = DarkBlue;
extern color Color_GBP = Red;
extern color Color_CHF = Chocolate;
extern color Color_JPY = Maroon;
extern color Color_AUD = DarkOrange;
extern color Color_CAD = Purple;
extern color Color_NZD = Teal;
extern int Line_Thickness = 2;
extern int All_Bars = 0;
extern int Last_Bars = 0;
string sub;
//----
double arrUSD[];
double arrEUR[];
double arrGBP[];
double arrCHF[];
double arrJPY[];
double arrAUD[];
double arrCAD[];
double arrNZD[];
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
  {
   //---- define if broker add caracters after the symbol
   sub=StringSubstr(Symbol(),6,3);
   
//---- indicators
   if(USD)
       Indicator_Name = StringConcatenate(Indicator_Name, " USD");
   if(EUR)
       Indicator_Name = StringConcatenate(Indicator_Name, " EUR");
   if(GBP)
       Indicator_Name = StringConcatenate(Indicator_Name, " GBP");
   if(CHF)
       Indicator_Name = StringConcatenate(Indicator_Name, " CHF");
   if(AUD)
       Indicator_Name = StringConcatenate(Indicator_Name, " AUD");
   if(CAD)
       Indicator_Name = StringConcatenate(Indicator_Name, " CAD");
   if(JPY)
       Indicator_Name = StringConcatenate(Indicator_Name, " JPY");
   if(NZD)
       Indicator_Name = StringConcatenate(Indicator_Name, " NZD");
   IndicatorShortName(Indicator_Name);
   int cur = 0; 
   int st = 23; 
   if(USD)
     {
       sl("~", cur, Color_USD);
       cur += st;
     }
   if(EUR)
     {
       sl("~", cur, Color_EUR);
       cur += st;
     }
   if(GBP)
     {
       sl("~", cur, Color_GBP);
       cur += st;
     }
   if(CHF)
     {
       sl("~", cur, Color_CHF);
       cur += st;
     }
   if(AUD)
     {
       sl("~", cur, Color_AUD);
       cur += st;
     }
   if(CAD)
     {
       sl("~", cur, Color_CAD);
       cur += st;
     }
   if(JPY)
     {
       sl("~", cur, Color_JPY);
       cur += st;
     }
   if(NZD)
     {
       sl("~", cur, Color_NZD);
       cur += st;
     }
   int width = 0;
   if(0 > StringFind(Symbol(), "USD", 0))
       width = 1;
   else 
       width = Line_Thickness;
   SetIndexStyle(0, DRAW_LINE, DRAW_LINE, width, Color_USD);
   SetIndexBuffer(0, arrUSD);
   SetIndexLabel(0, "USD"); 
   if(0 > StringFind(Symbol(), "EUR", 0))
       width = 1;
   else 
       width = Line_Thickness;
   SetIndexStyle(1, DRAW_LINE, DRAW_LINE, width, Color_EUR);
   SetIndexBuffer(1, arrEUR);
   SetIndexLabel(1, "EUR"); 
   if(0 > StringFind(Symbol(), "GBP", 0))
       width = 1;
   else 
       width = Line_Thickness;
   SetIndexStyle(2, DRAW_LINE, DRAW_LINE, width, Color_GBP);
   SetIndexBuffer(2, arrGBP);
   SetIndexLabel(2, "GBP"); 
   if(0 > StringFind(Symbol(), "CHF", 0))
       width = 1;
   else 
       width = Line_Thickness;
   SetIndexStyle(3, DRAW_LINE, DRAW_LINE, width, Color_CHF);
   SetIndexBuffer(3, arrCHF);
   SetIndexLabel(3, "CHF"); 
   if(0 > StringFind(Symbol(), "JPY", 0))
       width = 1;
   else 
       width = Line_Thickness;
   SetIndexStyle(4, DRAW_LINE, DRAW_LINE, width, Color_JPY);
   SetIndexBuffer(4, arrJPY);
   SetIndexLabel(4, "JPY"); 
   if(0 > StringFind(Symbol(), "AUD", 0))
       width = 1;
   else 
       width = Line_Thickness;
   SetIndexStyle(5, DRAW_LINE, DRAW_LINE, width, Color_AUD);
   SetIndexBuffer(5, arrAUD);
   SetIndexLabel(5, "AUD"); 
   if(0 > StringFind(Symbol(), "CAD", 0))
       width = 1;
   else 
       width = Line_Thickness;
   SetIndexStyle(6, DRAW_LINE, DRAW_LINE, width, Color_CAD);
   SetIndexBuffer(6, arrCAD);
   SetIndexLabel(6, "CAD"); 
   if(0 > StringFind(Symbol(), "NZD", 0))
       width = 1;
   else 
       width = Line_Thickness;
   SetIndexStyle(7, DRAW_LINE, DRAW_LINE, width, Color_NZD);
   SetIndexBuffer(7, arrNZD);
   SetIndexLabel(7, "NZD"); 
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator deinitialization function                       |
//+------------------------------------------------------------------+
int deinit()
  {
//----
   for(int i = 0; i < Objs; i++)
     {
      if(!ObjectDelete(Indicator_Name + i))
          Print("error: code #", GetLastError());
     }
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int start()
  {
   int limit;
   int counted_bars = IndicatorCounted();
//---- ïðîâåðêà íà âîçìîæíûå îøèáêè
   if(counted_bars < 0) 
       return(-1);
//---- ïîñëåäíèé ïîñ÷èòàííûé áàð áóäåò ïåðåñ÷èòàí
   if(All_Bars < 1)
       All_Bars = Bars;
   if(counted_bars > 0 && Last_Bars > 0) 
       counted_bars -= Last_Bars;
   limit = All_Bars - counted_bars;
//---- îñíîâíîé öèêë
   for(int i = 0; i < limit; i++)
     {
       // Ïðåäâàðèòåëüíûé ðàññ÷åò
       if(EUR)
         {
           double EURUSD_Fast = ma("EURUSD"+sub, Fast, MA_Method, Price, i);
           double EURUSD_Slow = ma("EURUSD"+sub, Slow, MA_Method, Price, i);
           if(!EURUSD_Fast || !EURUSD_Slow)
               break;
         }
       if(GBP)
         {
           double GBPUSD_Fast = ma("GBPUSD"+sub, Fast, MA_Method, Price, i);
           double GBPUSD_Slow = ma("GBPUSD"+sub, Slow, MA_Method, Price, i);
           if(!GBPUSD_Fast || !GBPUSD_Slow)
               break;
         }
       if(AUD)
         {
           double AUDUSD_Fast = ma("AUDUSD"+sub, Fast, MA_Method, Price, i);
           double AUDUSD_Slow = ma("AUDUSD"+sub, Slow, MA_Method, Price, i);
           if(!AUDUSD_Fast || !AUDUSD_Slow)
               break;
         }
       if(NZD)
         {
           double NZDUSD_Fast = ma("NZDUSD"+sub, Fast, MA_Method, Price, i);
           double NZDUSD_Slow = ma("NZDUSD"+sub, Slow, MA_Method, Price, i);
           if(!NZDUSD_Fast || !NZDUSD_Slow)
               break;
         }
       if(CAD)
         {
           double USDCAD_Fast = ma("USDCAD"+sub, Fast, MA_Method, Price, i);
           double USDCAD_Slow = ma("USDCAD"+sub, Slow, MA_Method, Price, i);
           if(!USDCAD_Fast || !USDCAD_Slow)
               break;
         }
       if(CHF)
         {
           double USDCHF_Fast = ma("USDCHF"+sub, Fast, MA_Method, Price, i);
           double USDCHF_Slow = ma("USDCHF"+sub, Slow, MA_Method, Price, i);
           if(!USDCHF_Fast || !USDCHF_Slow)
               break;
         }
       if(JPY)
         {
           double USDJPY_Fast = ma("USDJPY"+sub, Fast, MA_Method, Price, i);
           double USDJPY_Slow = ma("USDJPY"+sub, Slow, MA_Method, Price, i);
           if(!USDJPY_Fast || !USDJPY_Slow)
               break;
         }
       // ðàññ÷åò âàëþò
       if(USD)
         {
           arrUSD[i] = 0;
           if(EUR) 
               arrUSD[i] += EURUSD_Slow / EURUSD_Fast - 1;
           if(GBP) 
               arrUSD[i] += GBPUSD_Slow / GBPUSD_Fast - 1;
           if(AUD) 
               arrUSD[i] += AUDUSD_Slow / AUDUSD_Fast - 1;
           if(NZD) 
               arrUSD[i] += NZDUSD_Slow / NZDUSD_Fast - 1;
           if(CHF) 
               arrUSD[i] += USDCHF_Fast / USDCHF_Slow - 1;
           if(CAD) 
               arrUSD[i] += USDCAD_Fast / USDCAD_Slow - 1;
           if(JPY) 
               arrUSD[i] += USDJPY_Fast / USDJPY_Slow - 1;
         }// end if USD
       if(EUR)
         {
           arrEUR[i] = 0;
           if(USD) 
               arrEUR[i] += EURUSD_Fast / EURUSD_Slow - 1;
           if(GBP) 
               arrEUR[i] += (EURUSD_Fast / GBPUSD_Fast) / 
                            (EURUSD_Slow/GBPUSD_Slow) - 1;
           if(AUD) 
               arrEUR[i] += (EURUSD_Fast / AUDUSD_Fast) / 
                            (EURUSD_Slow/AUDUSD_Slow) - 1;
           if(NZD) 
               arrEUR[i] += (EURUSD_Fast / NZDUSD_Fast) / 
                            (EURUSD_Slow/NZDUSD_Slow) - 1;
           if(CHF) 
               arrEUR[i] += (EURUSD_Fast*USDCHF_Fast) / 
                            (EURUSD_Slow*USDCHF_Slow) - 1;
           if(CAD) 
               arrEUR[i] += (EURUSD_Fast*USDCAD_Fast) / 
                            (EURUSD_Slow*USDCAD_Slow) - 1;
           if(JPY) 
               arrEUR[i] += (EURUSD_Fast*USDJPY_Fast) / 
                            (EURUSD_Slow*USDJPY_Slow) - 1;
         }// end if EUR
       if(GBP)
         {
           arrGBP[i] = 0;
           if(USD) 
               arrGBP[i] += GBPUSD_Fast / GBPUSD_Slow - 1;
           if(EUR) 
               arrGBP[i] += (EURUSD_Slow / GBPUSD_Slow) / 
                            (EURUSD_Fast / GBPUSD_Fast) - 1;
           if(AUD) 
               arrGBP[i] += (GBPUSD_Fast / AUDUSD_Fast) / 
                            (GBPUSD_Slow / AUDUSD_Slow) - 1;
           if(NZD) 
               arrGBP[i] += (GBPUSD_Fast / NZDUSD_Fast) / 
                            (GBPUSD_Slow / NZDUSD_Slow) - 1;
           if(CHF) 
               arrGBP[i] += (GBPUSD_Fast*USDCHF_Fast) / 
                            (GBPUSD_Slow*USDCHF_Slow) - 1;
           if(CAD) 
               arrGBP[i] += (GBPUSD_Fast*USDCAD_Fast) / 
                            (GBPUSD_Slow*USDCAD_Slow) - 1;
           if(JPY) 
               arrGBP[i] += (GBPUSD_Fast*USDJPY_Fast) / 
                            (GBPUSD_Slow*USDJPY_Slow) - 1;
          }// end if GBP
       if(AUD)
         {
           arrAUD[i] = 0;
           if(USD) 
               arrAUD[i] += AUDUSD_Fast / AUDUSD_Slow - 1;
           if(EUR) 
               arrAUD[i] += (EURUSD_Slow / AUDUSD_Slow) / 
                            (EURUSD_Fast / AUDUSD_Fast) - 1;
           if(GBP) 
               arrAUD[i] += (GBPUSD_Slow / AUDUSD_Slow) / 
                            (GBPUSD_Fast / AUDUSD_Fast) - 1;
           if(NZD) 
               arrAUD[i] += (AUDUSD_Fast/NZDUSD_Fast) / 
                            (AUDUSD_Slow / NZDUSD_Slow) - 1;
           if(CHF) 
               arrAUD[i] += (AUDUSD_Fast*USDCHF_Fast) / 
                            (AUDUSD_Slow*USDCHF_Slow) - 1;
           if(CAD) 
               arrAUD[i] += (AUDUSD_Fast*USDCAD_Fast) / 
                            (AUDUSD_Slow*USDCAD_Slow) - 1;
           if(JPY) 
               arrAUD[i] += (AUDUSD_Fast*USDJPY_Fast) / 
                            (AUDUSD_Slow*USDJPY_Slow) - 1;
         }// end if AUD
       if(NZD)
         {
           arrNZD[i] = 0;
           if(USD) 
               arrNZD[i] += NZDUSD_Fast / NZDUSD_Slow - 1;
           if(EUR) 
               arrNZD[i] += (EURUSD_Slow / NZDUSD_Slow) / 
                            (EURUSD_Fast/NZDUSD_Fast) - 1;
           if(GBP) 
               arrNZD[i] += (GBPUSD_Slow / NZDUSD_Slow) / 
                            (GBPUSD_Fast / NZDUSD_Fast) - 1;
           if(AUD) 
               arrNZD[i] += (AUDUSD_Slow / NZDUSD_Slow) / 
                            (AUDUSD_Fast / NZDUSD_Fast) - 1;
           if(CHF) 
               arrNZD[i] += (NZDUSD_Fast*USDCHF_Fast) / 
                            (NZDUSD_Slow*USDCHF_Slow) - 1;
           if(CAD) 
               arrNZD[i] += (NZDUSD_Fast*USDCAD_Fast) / 
                            (NZDUSD_Slow*USDCAD_Slow) - 1;
           if(JPY) 
               arrNZD[i] += (NZDUSD_Fast*USDJPY_Fast) / 
                            (NZDUSD_Slow*USDJPY_Slow) - 1;
         }// end if NZD
       if(CAD)
         {
           arrCAD[i] = 0;
           if(USD) 
               arrCAD[i] += USDCAD_Slow / USDCAD_Fast - 1;
           if(EUR) 
               arrCAD[i] += (EURUSD_Slow*USDCAD_Slow) / 
                            (EURUSD_Fast*USDCAD_Fast) - 1;
           if(GBP) 
               arrCAD[i] += (GBPUSD_Slow*USDCAD_Slow) / 
                            (GBPUSD_Fast*USDCAD_Fast) - 1;
           if(AUD) 
               arrCAD[i] += (AUDUSD_Slow*USDCAD_Slow) / 
                            (AUDUSD_Fast*USDCAD_Fast) - 1;
           if(NZD) 
               arrCAD[i] += (NZDUSD_Slow*USDCAD_Slow) / 
                            (NZDUSD_Fast*USDCAD_Fast) - 1;
           if(CHF) 
               arrCAD[i] += (USDCHF_Fast / USDCAD_Fast) / 
                            (USDCHF_Slow / USDCAD_Slow) - 1;
           if(JPY) 
               arrCAD[i] += (USDJPY_Fast / USDCAD_Fast) / 
                            (USDJPY_Slow / USDCAD_Slow) - 1;
         }// end if CAD
       if(CHF)
         {
           arrCHF[i] = 0;
           if(USD) 
               arrCHF[i] += USDCHF_Slow / USDCHF_Fast - 1;
           if(EUR) 
               arrCHF[i] += (EURUSD_Slow*USDCHF_Slow) / 
                            (EURUSD_Fast*USDCHF_Fast) - 1;
           if(GBP) 
               arrCHF[i] += (GBPUSD_Slow*USDCHF_Slow) / 
                            (GBPUSD_Fast*USDCHF_Fast) - 1;
           if(AUD) 
               arrCHF[i] += (AUDUSD_Slow*USDCHF_Slow) / 
                            (AUDUSD_Fast*USDCHF_Fast) - 1;
           if(NZD) 
               arrCHF[i] += (NZDUSD_Slow*USDCHF_Slow) / 
                            (NZDUSD_Fast*USDCHF_Fast) - 1;
           if(CAD) 
               arrCHF[i] += (USDCHF_Slow / USDCAD_Slow) / 
                            (USDCHF_Fast / USDCAD_Fast) - 1;
           if(JPY) 
               arrCHF[i] += (USDJPY_Fast / USDCHF_Fast) / 
                            (USDJPY_Slow / USDCHF_Slow) - 1;
         }// end if CHF
       if(JPY)
         {
           arrJPY[i] = 0;
           if(USD) 
               arrJPY[i] += USDJPY_Slow / USDJPY_Fast - 1;
           if(EUR) 
               arrJPY[i] += (EURUSD_Slow*USDJPY_Slow) / 
                            (EURUSD_Fast*USDJPY_Fast) - 1;
           if(GBP) 
               arrJPY[i] += (GBPUSD_Slow*USDJPY_Slow) / 
                            (GBPUSD_Fast*USDJPY_Fast) - 1;
           if(AUD) 
               arrJPY[i] += (AUDUSD_Slow*USDJPY_Slow) / 
                            (AUDUSD_Fast*USDJPY_Fast) - 1;
           if(NZD) 
               arrJPY[i] += (NZDUSD_Slow*USDJPY_Slow) / 
                            (NZDUSD_Fast*USDJPY_Fast) - 1;
           if(CAD) 
               arrJPY[i] += (USDJPY_Slow/USDCAD_Slow) / 
                            (USDJPY_Fast/USDCAD_Fast) - 1;
           if(CHF) 
               arrJPY[i] += (USDJPY_Slow/USDCHF_Slow) / 
                            (USDJPY_Fast/USDCHF_Fast) - 1;
         }// end if JPY
     }//end block for(int i=0; i<limit; i++)
//----
   return(0);
  }
//+------------------------------------------------------------------+
//|  Subroutines                                                     |
//+------------------------------------------------------------------+
double ma(string sym, int per, int Mode, int Price, int i)
  {
   double res = 0;
   int k = 1;
   int ma_shift = 0;
   int tf = 0;
   switch(Period())
     {
       case 1:     res += iMA(sym, tf, per*k, ma_shift, Mode, Price, i); 
                   k += 5;
       case 5:     res += iMA(sym, tf, per*k, ma_shift, Mode, Price, i); 
                   k += 3;
       case 15:    res += iMA(sym, tf, per*k, ma_shift, Mode, Price, i); 
                   k += 2;
       case 30:    res += iMA(sym, tf, per*k, ma_shift, Mode, Price, i); 
                   k += 2;
       case 60:    res += iMA(sym, tf, per*k, ma_shift, Mode, Price, i); 
                   k += 4;
       case 240:   res += iMA(sym, tf, per*k, ma_shift, Mode, Price, i); 
                   k += 6;
       case 1440:  res += iMA(sym, tf, per*k, ma_shift, Mode, Price, i); 
                   k += 4;
       case 10080: res += iMA(sym, tf, per*k, ma_shift, Mode, Price, i); 
                   k +=4;
       case 43200: res += iMA(sym, tf, per*k, ma_shift, Mode, Price, i); 
     } 
   return(res);
  }   
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void sl(string sym, int y, color col)
  {
   int window = WindowFind(Indicator_Name);
   string ID = Indicator_Name+Objs;
   int tmp = 10 + y;
   Objs++;
   if(ObjectCreate(ID, OBJ_LABEL, window, 0, 0))
     {
       //ObjectSet(ID, OBJPROP_CORNER, 1);
       ObjectSet(ID, OBJPROP_XDISTANCE, y + 35);
       ObjectSet(ID, OBJPROP_YDISTANCE, 0);
       ObjectSetText(ID, sym, 18, "Arial Black", col);
     }
  }   
//+------------------------------------------------------------------+

Quoting Blazer

Disliked

Alo alo,

The ea open many orders and seems it works normal without reverse suggestions

Ignored

Quoting matrixebiz

Disliked

Hey Guys,

Here is an updated version of my EA. Please test and let me know how you make out. The Trade levels may be off but I don’t have a lot of time to test so if you guys could compare results with the spreadsheet and the FerruFX indi that would be great
What I’ve added is the ability to not trade the Sunday candles if you don’t want. Added MagicNumber to be compatible with different EA’s on the same chart. Added trade level options (Please test). Added the ability to select only the currencies you want the EA to trade just as the FerruFX indicator.
I was told that with the old EA if you had trades open still when the new trade bar comes along, the old EA would...

Ignored

Quoting Kang_Gun

Disliked

Thanks matrixebiz...

Should your EA use CCFp.ex4 attached, or we can use the original one ?

KG

Ignored

Quoting youby

Disliked

hello everyone .. here it's my first time to post a reply in this great forum ..
i wish i could read the hole theread .. but it's over 70 pages .. too larg for me .. hhhh
would you execuse me , i just wanna ask about this indicator .. it's like a runied gun , sometimes it shoot good , and take a nice gool , and sometimes it shoot back and kill it's holder .. !!
i just heard about new something in this indecator that ppl use it in the both of american and euoropian markets .. and there it works good ..
i'm trying it myself .. i just wanna share you , and make sure of this information !!
i'd love to hear from you .. thnx alot !
youby

Ignored

Quote

Disliked

The reason to 0pen this thread again is to explore and find the best setup. So the holder will not killed...

KG

Quoting Ronald Raygun

Disliked

FerruFX, I know you don't put external buffers in your indicator. How have you been able to solve that problem I'm having with the CCFp indicator? Did you have to convert the indicator into some sort of function, and then call that function?

Ignored

Quoting youby

Disliked

thnx alot for that quick replying ..
but i still dunno , is that true that the indicator dosn't work fine in the japanise markets ???

Ignored

Quoting ahendon

Disliked

I do have to keep closing my platform and reopening after every round of trades so I am probably missing trades because I do sleep occasionally.

really great work RR!

Ignored