help writing this script

Quoting jtmoore007

Disliked

Ok let me start off by saying that i have...

Ignored

//+------------------------------------------------------------------+
//|                                             Open_Pending_Buy.mq4 |
//|                                                         Zen_Leow |
//|                                                                  |
//+------------------------------------------------------------------+
/* This script opens a pending buy order at a set amt of pips above
   the previous candle's HIGH, with a stoploss at a set amt of pips
   below the previous candle's CLOSE. along with a takeprofit
   at a set number of pips above the open price. */
#property copyright "Zen_Leow"
#property link      ""
/* We use the extern keyword to declare variables for user input 
   we have to define what TYPE it is, what NAME it has and what is 
   it's DAFAULT value. */
/*
Keyword   Type     Name                      Default value */   
extern    int      Set_Pips_Apart_Open   =   3;
extern    int      Set_Pips_Apart_SL     =   7;
extern    double   LotSize               =   0.1;
extern    int      Slippage              =   3;
extern    int      TakeProfitPips        =   10;

//+------------------------------------------------------------------+
/* 
   This is where we define the functions so we can call them from
   (almost) anywhere in the code.
   
   A function declaration consist of a "return type", "function name",
   "arguments aka parameters"
   
   The "Return type" portion is used to declare what type of info
   will THIS function eventually come up with and give back to the
   function that calls it. 
   "I'll return a interger (int)?"
   "I'll return a decimal number (double)?"
   "I'll return a True/False answer? (bool)?"
   "I'll return a character (char)?" 
   "I'll return a string of characters (string)?"
   "I'll return a Color (color)?"
   "I'll return a Date and time (datetime)?"
   "I'm not expected to return anything (void)"
   
   fyi, int, double, bool and string are the most commonly used.
   void is used when you just want that function to DO something 
   and be done with it.
   
   The "Function name" is what you use when you want to call for 
   the services of this function.
   
   The "Arguments" are enclosed in parenthesis. They define what
   infomation this function needs to do its job. 
   Multiple arguments are separated by comma ",".
   There can be no arguments too. just leave the paranthesis blank.
*/
/*
Return Type   Function Name     Arguments  */
bool          SendMyOrder      (double OpenPrice, double StopLoss, double TakeProfit, string comments)
{
   int PositionType = 0;
   int ticket = 0;
   
   if (OpenPrice > Ask)
   {
      PositionType = OP_BUYSTOP;
   }
   if (OpenPrice < Ask)
   {
      PositionType = OP_BUYLIMIT;
   }
   
   // This sends our order to the broker's server and it should return us an integer number for ticket if successful.
   ticket = OrderSend(Symbol(), PositionType, LotSize, OpenPrice, Slippage, StopLoss, TakeProfit, comments, 0, 0, Green);
   
   if(ticket>0) // if OrderSend gives us back a ticket number, that means the order was successfully opened.
   {
      if(OrderSelect(ticket,SELECT_BY_TICKET,MODE_TRADES)) 
      {
         return (true);
      }
   }
   else // something's wrong with the trade execution...
   {  
      Print("CANNOT open BUY pending position...");
      return (false);
   }
}
/* This is what I mean by exaggerating the use of function. 
   Some people find it too long winded to have a function
   with just 1 line of calculation. 
   but it does make your eventual code easier to read. */
double GetOpenPrice(int index)
{
   double MyOpenPrice = High[index] + (Set_Pips_Apart_Open * Point);
   
   return (MyOpenPrice);
}
/* example of function with no arguments */
double GetStopLossPrice()
{
   double MyStopLossPrice = Close[1] - (Set_Pips_Apart_SL * Point);
   
   return (MyStopLossPrice);
}
/* You can squeeze the calculation into the return statement if you want
   so long as the equation can give you something that matches the return type
   but I don't recommend this for complicated equations. */
double GetTakeProfitPrice(double TheOpenPrice, int TP_Pips)
{
   return (TheOpenPrice + (TP_Pips * Point));
}

//+------------------------------------------------------------------+
//| script program start function                                    |
//+------------------------------------------------------------------+
/* This is the function that runs when you attach the script.
   You can choose to write all your codes in here but good practise
   is to split them up into smaller, manageable functions and call
   them from here. I'll demonstrate this by exaggerating function usage */
int start()
{
//----
   double TheOpenPrice = GetOpenPrice(1);
   double TheStopLossPrice = GetStopLossPrice();
   double TheTakeProfitPrice = GetTakeProfitPrice(TheOpenPrice, TakeProfitPips);
   
   // using the values obtained from those functions, we can place our order.
   bool OrderSuccessful = SendMyOrder(TheOpenPrice, TheStopLossPrice, TheTakeProfitPrice, "Script Opened BUY");
   
   if (OrderSuccessful) // This means the function returned "true"
   {
      Print("BUY pending order opened : ",OrderOpenPrice()); // This message will show up in your journal/expert tab
   }
   else // This means that function return "false".
   {
      Print("CANNOT open BUY pending position...");
   }
//----
   return(0);
}