How do you protect an EA or Indicator?? (A working way)

//+--------------------------------------------------+
//|PM2
//+--------------------------------------------------+ 
 
int Account = 15613;
#include  <stdlib.mqh>
#define   NL    "n"
 
// Regular Variables
extern double MinTime               =  91;
extern double Lots                  =  0.1;      
extern double Increment             =  0;
extern bool   Multiplier            =  false;
extern double ProfitReducer         =  0.75;
extern int    ProfitTarget          =  50;
extern int    Spacing               =  2;
extern int    TrendSpacing          =  2;
extern double CounterTrendMultiplier=  2;
extern bool   EndTrading            =  false;  

[b][color=Red]int ApprovedAccount = 123456;[/color][/b] [b][color=Red]//This is the account number[/color][/b]
 
// ixternal settings
int      Step          = 1;
int      Orders        = 1;    
int      Slippage      = 0;                   
int      MagicNumber   = 7476253781;     
string   TradeComment  = "PipMaker v2a";
datetime BarTime       = 0;                    
static bool     TradeAllowed  = true;             
bool     Boost         = false;
double   BoostTrack    = 0;                
bool     OppositeClose = true;
 
//+-------------+
//| Custom init |
//|-------------+
int init()
  {
 
  }
 
//+----------------+
//| Custom DE-init |
//+----------------+
 
int deinit()
  {
 
  }
 
void CloseBuysinProfit()
{
  double OrdersBUY, BuyProfit, LastBuyTime;
 
   for(int i = OrdersTotal()-1; i >=0; i--)
       {
       OrderSelect(i, SELECT_BY_POS);
       bool result = false;
       if (OrderSymbol()==Symbol() && OrderMagicNumber() == MagicNumber && OrderType() == OP_BUY)  
         {
           BuyProfit = OrderProfit() + OrderSwap() + OrderCommission();
           if (OrderOpenTime()>LastBuyTime) LastBuyTime=OrderOpenTime();
if (TimeCurrent()-LastBuyTime >=MinTime && (OrderProfit()+OrderSwap()+OrderCom mission())>0) result = OrderClose( OrderTicket(), OrderLots(), MarketInfo(OrderSymbol(), MODE_BID), 5, Red );
         }
       }
  return; 
}
 
//+-----------------------------------------------+
//| Closes all Sells in Profit                   
//+-----------------------------------------------+
void CloseSellsinProfit()
{
  double OrdersSELL, SellProfit, LastSellTime;
 
   for(int i = OrdersTotal()-1; i >=0; i--)
      {
      OrderSelect(i, SELECT_BY_POS);
      bool result = false;
      if (OrderSymbol()==Symbol() && OrderMagicNumber() == MagicNumber && OrderType() == OP_SELL)  
       {
         SellProfit = OrderProfit() + OrderSwap() + OrderCommission();
         if (OrderOpenTime()>LastSellTime) LastSellTime=OrderOpenTime();
if (TimeCurrent()-LastSellTime >=MinTime && (OrderProfit()+OrderSwap()+OrderCom mission())>0) result = OrderClose(OrderTicket(), OrderLots(), MarketInfo(OrderSymbol(), MODE_ASK), 5, Red);
       }
     }
 
  return; 
}
 
//+------------------------------------------------------------------+
//| Check for BUY order conditions                                   |
//+------------------------------------------------------------------+
void CheckForBuy()
  {
   double BuyOrders, OrderSize;
   double LowestBuy = 1000, HighestBuy;
   int    cnt = 0;
   int    gle = 0;
 
   if (BarTime != Time[0])
   {
      BarTime = Time[0];
      BoostTrack = 0;
      TradeAllowed = true;
   }
 
   RefreshRates();
 
   for (cnt = OrdersTotal(); cnt >= 0; cnt--)
   {
      OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES);
      if (OrderSymbol() == Symbol() && OrderType() == OP_BUY && OrderMagicNumber() == MagicNumber)
      {
         if (OrderOpenPrice() < LowestBuy) LowestBuy = OrderOpenPrice();
         if (OrderOpenPrice() > HighestBuy) HighestBuy = OrderOpenPrice();
         BuyOrders++;
      }
   }
 
   if (TradeAllowed && Multiplier)
   {
      if (Ask >= HighestBuy + (TrendSpacing * Point))
      {
//         for (int i = 1; i < Orders + 1; i++)
//         {
OrderSize = Lots * (MathPow(Increment, BuyOrders) / Orders);
if (OrderSize == 0) OrderSize = Lots;
            OrderSend(Symbol(), OP_BUY, OrderSize, Ask, Slippage, 0, 0, TradeComment, MagicNumber, Blue);
            Print(AccountMargin());
//         }
         gle = GetLastError();
         if (gle == 0)
         {
            BoostTrack = Close[0];
            TradeAllowed = false;
         }
      }
      if (Ask <= LowestBuy - (Spacing * Point))
      {
//         for (int l = 1; l < Orders + 1; l++)
//         {
OrderSize = Lots * CounterTrendMultiplier * (MathPow(Increment, BuyOrders) / Orders);
if (OrderSize == 0) OrderSize = Lots * CounterTrendMultiplier;
            OrderSend(Symbol(), OP_BUY, OrderSize, Ask, Slippage, 0, 0, TradeComment, MagicNumber, Blue);
            Print(AccountMargin());
//         }
         gle = GetLastError();
         if (gle == 0)
         {
            BoostTrack = Close[0];
            TradeAllowed = false;
         }
      }
   }
 
   if (TradeAllowed && !Multiplier)
   {
      if (Ask >= HighestBuy + (TrendSpacing * Point))
      {
//         for(int o = 1; o < Orders + 1; o++)
//         {
OrderSize = Lots + ((BuyOrders * Increment) / Orders);
if (OrderSize == 0) OrderSize = Lots;
            OrderSend(Symbol(), OP_BUY, OrderSize, Ask, Slippage, 0, 0, TradeComment, MagicNumber, Blue);
            Print(AccountMargin());
//         }
         gle = GetLastError();
         if (gle == 0)
         {
            BoostTrack = Close[0];
            TradeAllowed = false;
         }
      }
      if (Ask <= LowestBuy - (Spacing * Point))
      {
//         for (int m = 1; m < Orders + 1; m++)
//         {
OrderSize = (Lots * CounterTrendMultiplier) + ((BuyOrders * Increment) / Orders);
if (OrderSize == 0) OrderSize = Lots * CounterTrendMultiplier;
            OrderSend(Symbol(), OP_BUY, OrderSize, Ask, Slippage, 0, 0, TradeComment, MagicNumber, Blue);
            Print(AccountMargin());
//         }
         gle = GetLastError();
         if (gle == 0)
         {
            BoostTrack = Close[0];
            TradeAllowed = false;
         }
      }
   }
}
 
 
//+------------------------------------------------------------------+
//| Check for SELL order conditions                                  |
//+------------------------------------------------------------------+
void CheckForSell()
{
   double SellOrders, OrderSize;
   double HighestSell, LowestSell = 999;
   int    cnt = 0;
   int    gle = 0;
 
   if (BarTime != Time[0])
   {
      BarTime = Time[0];
      BoostTrack = 0;
      TradeAllowed = true;
   }
 
   RefreshRates();
 
   for (cnt = OrdersTotal(); cnt >= 0; cnt--)
   {
      OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES);
      if (OrderSymbol() == Symbol() && OrderType() == OP_SELL && OrderMagicNumber() == MagicNumber)
      {
         if (OrderOpenPrice() > HighestSell) HighestSell = OrderOpenPrice();
         if (OrderOpenPrice() < LowestSell) LowestSell = OrderOpenPrice();
         SellOrders++;
      }
   }
 
   if (TradeAllowed && Multiplier)
   {
      if (Bid <= LowestSell - (TrendSpacing * Point))
      {
//         for (int i = 1; i < Orders + 1; i++)
//         {
OrderSize = Lots * (MathPow(Increment, SellOrders) / Orders);
if (OrderSize == 0) OrderSize = Lots;
            OrderSend(Symbol(), OP_SELL, OrderSize, Bid, Slippage, 0, 0, TradeComment, MagicNumber, Red);
            Print(AccountMargin());
//         }
         gle = GetLastError();
         if (gle == 0)
         {
            BoostTrack = Close[0];
            TradeAllowed = false;
         }
      }
      if (Bid >= HighestSell + (Spacing * Point))
      {
//         for(int l = 1; l < Orders + 1; l++)
//         {
OrderSize = Lots * CounterTrendMultiplier * (MathPow(Increment, SellOrders) / Orders);
if (OrderSize == 0) OrderSize = Lots * CounterTrendMultiplier;
            OrderSend(Symbol(), OP_SELL, OrderSize, Bid, Slippage, 0, 0, TradeComment, MagicNumber, Red);
            Print(AccountMargin());
//         }
         gle = GetLastError();
         if (gle == 0)
         {
            BoostTrack = Close[0];
            TradeAllowed = false;
         }
      }
   }
 
   if (TradeAllowed && !Multiplier)
   {
      if (Bid <= LowestSell - (TrendSpacing * Point))
      {
//         for (int o = 1; o < Orders + 1; o++)
//         {
OrderSize = Lots + ((SellOrders * Increment) / Orders);
if (OrderSize == 0) OrderSize = Lots;
            OrderSend(Symbol(), OP_SELL, OrderSize, Bid, Slippage, 0, 0, TradeComment, MagicNumber, Red);
            Print(AccountMargin());
//         }
         gle = GetLastError();
         if (gle == 0)
         {
            BoostTrack = Close[0];
            TradeAllowed = false;
         }
      }
      if (Bid >= HighestSell + (Spacing * Point))
      {
//         for (int m = 1; m < Orders + 1; m++)
//         {
OrderSize = (Lots * CounterTrendMultiplier) + ((SellOrders * Increment) / Orders);
if (OrderSize == 0) OrderSize = Lots * CounterTrendMultiplier;
            OrderSend(Symbol(), OP_SELL, OrderSize, Bid, Slippage, 0, 0, TradeComment, MagicNumber, Red);
            Print(AccountMargin());
//         }
         gle = GetLastError();
         if (gle == 0)
         {
            BoostTrack = Close[0];
            TradeAllowed = false;
         }
      }
   }
}
 
 
//+-----------+
//| Main      |
//+-----------+
int start()

   
 

[b][color=Red]{
if(ApprovedAccount != AccountNumber()) 
return(0);[/color][/b]
 
 

  {
 
// Regular count
 
   double         MarginPercent;
   static double  LowMarginPercent=10000000;
   double         BUYPipInfo, SELLPipInfo;
   double         i, OrdersSELL, OrdersBUY, BuyPips, SellPips, BuyLots, SellLots;
   static double  LowestBuy=1000, HighestBuy, LowestSell=1000, HighestSell, HighPoint, MidPoint, LowPoint;
   double         BuyProfit, SellProfit, PosBuyProfit, PosSellProfit;
   static double  HighestBuyTicket, LowestBuyTicket, HighestSellTicket, LowestSellTicket;
   double         HighestBuyProfit, LowestBuyProfit, HighestSellProfit, LowestSellProfit;
   double         CurrentTime = (TimeHour(CurTime()+TimeMinute(CurT  ime())));
   bool           SELLme = false;
   bool           BUYme = false;
   double         Margin = MarketInfo(Symbol(), MODE_MARGINREQUIRED);
 
   for(i = 0; i < OrdersTotal(); i++)
     {
      OrderSelect(i, SELECT_BY_POS, MODE_TRADES);
       if (OrderSymbol()==Symbol() && OrderMagicNumber() == MagicNumber)
        {
           if(OrderType()==OP_BUY && OrderOpenPrice()>HighestBuy) HighestBuy=OrderOpenPrice();
           if(OrderType()==OP_BUY && OrderOpenPrice()<LowestBuy) LowestBuy=OrderOpenPrice();
           if(OrderType()==OP_SELL && OrderOpenPrice()>HighestSell) HighestSell=OrderOpenPrice();
           if(OrderType()==OP_SELL && OrderOpenPrice()<LowestSell) LowestSell=OrderOpenPrice();
           if(OrderType()==OP_BUY && OrderOpenPrice()==HighestBuy) HighestBuyTicket=OrderTicket();
           if(OrderType()==OP_SELL && OrderOpenPrice()==LowestSell) LowestSellTicket=OrderTicket();
if(OrderType()==OP_BUY && OrderTicket()==HighestBuyTicket) HighestBuyProfit=OrderProfit() + OrderSwap() + OrderCommission();
if(OrderType()==OP_SELL && OrderTicket()==LowestBuyTicket) LowestBuyProfit=OrderProfit() + OrderSwap() + OrderCommission();
if(OrderType()==OP_BUY && OrderTicket()==HighestSellTicket) HighestSellProfit=OrderProfit() + OrderSwap() + OrderCommission();
if(OrderType()==OP_SELL && OrderTicket()==LowestSellTicket) LowestSellProfit=OrderProfit() + OrderSwap() + OrderCommission();
           if(OrderType()==OP_BUY)  OrdersBUY++;
           if(OrderType()==OP_SELL) OrdersSELL++;
           if(OrderType()==OP_BUY)  BuyLots += OrderLots();
           if(OrderType()==OP_SELL) SellLots += OrderLots();
           if(OrderType()==OP_BUY)  BuyProfit += OrderProfit() + OrderCommission() + OrderSwap();
           if(OrderType()==OP_SELL) SellProfit += OrderProfit() + OrderCommission() + OrderSwap();
if(OrderType()==OP_BUY && (OrderProfit() + OrderSwap() + OrderCommission())>0) PosBuyProfit += OrderProfit() + OrderCommission() + OrderSwap();
if(OrderType()==OP_SELL && (OrderProfit() + OrderSwap() + OrderCommission())>0) PosSellProfit += OrderProfit() + OrderCommission() + OrderSwap();
        }
     }
 
      BUYPipInfo = ProfitTarget;
      SELLPipInfo = ProfitTarget;
 
   if (HighestBuy > HighestSell)
      {
         HighPoint = HighestBuy;}
      else {
         HighPoint = HighestSell;
      }
 
   if (LowestBuy < LowestSell)
      {
         LowPoint = LowestBuy;}
      else {
         LowPoint = LowestSell;
      }
 
 
if ((OrdersSELL > 1 && OrdersBUY > 0) || (OrdersSELL > 0 && OrdersBUY > 1)) MidPoint = (HighPoint + LowPoint) / 2;
 
   if (Bid>MidPoint){
      if((PosBuyProfit + LowestSellProfit) >= ProfitTarget && LowestSell < LowestBuy)
         {  
            OrderSelect(LowestSellTicket, SELECT_BY_TICKET);
            OrderClose(OrderTicket(), OrderLots(), MarketInfo(OrderSymbol(), MODE_ASK), 5, Red);
            CloseBuysinProfit();
            LowestBuy=1000;HighestBuy=0;
            LowestSellTicket=0;
         }
 
      if((PosSellProfit + LowestSellProfit) >= ProfitTarget && LowestSell < LowestBuy)
         {
            OrderSelect(LowestSellTicket, SELECT_BY_TICKET);
            OrderClose(OrderTicket(), OrderLots(), MarketInfo(OrderSymbol(), MODE_ASK), 5, Red);
            CloseSellsinProfit();
            LowestSell=1000;HighestSell=0;
            LowestSellTicket=0;
         }
 
      if((PosBuyProfit + LowestBuyProfit) >= ProfitTarget && LowestBuy < LowestSell)
         {  
            OrderSelect(LowestBuyTicket, SELECT_BY_TICKET);
            OrderClose(OrderTicket(), OrderLots(), MarketInfo(OrderSymbol(), MODE_BID), 5, Red);
            CloseBuysinProfit();
            LowestBuy=1000; HighestBuy=0;
            LowestBuyTicket=0;
         }
 
      if((PosSellProfit + LowestBuyProfit) >= ProfitTarget && LowestBuy < LowestSell)
         {
            OrderSelect(LowestBuyTicket, SELECT_BY_TICKET);
            OrderClose(OrderTicket(), OrderLots(), MarketInfo(OrderSymbol(), MODE_BID), 5, Red);
            CloseSellsinProfit();
            LowestSell=1000; HighestSell=0;
            LowestBuyTicket=0;
         }
      }
 
   if (Bid<MidPoint){
      if((PosBuyProfit + HighestBuyProfit) >= ProfitTarget && HighestBuy > HighestSell)
         {  
            OrderSelect(HighestBuyTicket, SELECT_BY_TICKET);
            OrderClose(OrderTicket(), OrderLots(), MarketInfo(OrderSymbol(), MODE_BID), 5, Red);
            CloseBuysinProfit();
            LowestBuy=999; HighestBuy=0;
            HighestBuyTicket=0;
         }
 
      if((PosSellProfit + HighestBuyProfit) >= ProfitTarget && HighestBuy > HighestSell)
         {
            OrderSelect(HighestBuyTicket, SELECT_BY_TICKET);
            OrderClose(OrderTicket(), OrderLots(), MarketInfo(OrderSymbol(), MODE_BID), 5, Red);
            CloseSellsinProfit();
            LowestSell=1000;HighestSell=0;
            HighestBuyTicket=0;
         }
      if((PosBuyProfit + HighestSellProfit) >= ProfitTarget && HighestSell > HighestBuy)
         {  
            OrderSelect(HighestSellTicket, SELECT_BY_TICKET);
            OrderClose(OrderTicket(), OrderLots(), MarketInfo(OrderSymbol(), MODE_ASK), 5, Red);
            CloseBuysinProfit();
            LowestBuy=1000; HighestBuy=0;
            HighestSellTicket=0;
         }
 
      if((PosSellProfit + HighestSellProfit) >= ProfitTarget && HighestSell > HighestBuy)
         {
            OrderSelect(HighestSellTicket, SELECT_BY_TICKET);
            OrderClose(OrderTicket(), OrderLots(), MarketInfo(OrderSymbol(), MODE_ASK), 5, Red);
            CloseSellsinProfit();
            LowestSell=1000;HighestSell=0;
            HighestSellTicket=0;
         }
      }
 
// BUY Trade Criteria
 
 
    if (Ask <= LowestBuy-(Spacing*Point) || Ask >= HighestBuy+(TrendSpacing*Point))
       {
       BUYme=true;  
       if(Boost && BoostTrack>0 && Close[0]<BoostTrack)
         {
         BUYme=true;
         TradeAllowed=true;
         }
      }
    if (EndTrading == true && OrdersBUY == 0) BUYme = false;
    if (BUYme == true) CheckForBuy(); 
 
// SELL Trade Criteria
 
    if (Bid >= HighestSell+(Spacing*Point) || Bid <= LowestSell-(TrendSpacing*Point))
       {
       SELLme=true; 
       if(Boost && BoostTrack>0 && Close[0]>BoostTrack)
        {
         SELLme=true; 
         TradeAllowed=true;
        }
     } 
    if (EndTrading == true && OrdersSELL == 0) SELLme = false;
    if (SELLme == true) CheckForSell();
 
 
//   if (OrdersBUY == 0 && OrdersSELL == 0) MarginPercent = 0;
//   else
   MarginPercent = MathRound((AccountEquity()/AccountMargin())*100);
 
   if (LowMarginPercent > MarginPercent) LowMarginPercent = MarginPercent;
 
 
   Comment("                    PipMaker v2a Last Update 06-23-2007 12:01pm", NL,
           "                            ProfitTarget ", BUYPipInfo, NL,
           "                            Buys    ", OrdersBUY, NL,
           "                            BuyLots        ", BuyLots, NL,
           "                            BuyProfit             ", BuyProfit, NL,
           "                            Highest Buy  ", HighestBuy, NL, NL,
           "                            ProfitTarget ", SELLPipInfo, NL,
           "                            Sells    ", OrdersSELL, NL,
           "                            SellLots        ", SellLots, NL,
           "                            SellProfit             ", SellProfit, NL,
           "                            Lowest Sell    ", LowestSell, NL, NL,
           "                            Balance ", AccountBalance(), NL,
           "                            Equity        ", AccountEquity(), NL, NL,
           "                            Margin      ", MathRound(AccountMargin()), NL,
           "                            MarginPercent        ", MarginPercent, NL,
           "                            LowMarginPercent     ", LowMarginPercent, NL,
" Current Time is ",TimeHour(TimeCurrent()),":",TimeM inute(TimeCurrent()),".",TimeSecond s(TimeCurrent())); 
 
 
//----------------------------------------------------------//
// Low Margin Percent Label                                 //
//----------------------------------------------------------//
 
   string MarPercent = DoubleToStr(MarginPercent,0);
   string LowMarPercent = DoubleToStr(LowMarginPercent,0);
 
   string ACCBAL     = DoubleToStr(AccountBalance(),0);
   ObjectDelete("MarginPercent");
   ObjectDelete("LowMarginPercent");
 
   if(ObjectFind("MarginPercent") != 0)
   {
   ObjectCreate("MarginPercent", OBJ_TEXT, 0, Time[0], Close[0]+20*Point);
   ObjectSetText("MarginPercent", MarPercent+"%  "+LowMarPercent+"%   $"+ACCBAL, 24, "Arial", White);
   }
   else
   {
   ObjectMove("MarginPercent", 0, Time[0], Close[0]+20*Point);
   }
 
//----------------------------------------------------------//
// Mid Point Line                                           //
//----------------------------------------------------------//
   if(ObjectFind("MidPoint") != 0)
   {
   ObjectCreate("MidPoint", OBJ_HLINE, 0, Time[0], MidPoint);
      ObjectSet("MidPoint", OBJPROP_COLOR, Yellow);
      ObjectSet("MidPoint", OBJPROP_WIDTH, 2);
   }
   else
   {
   ObjectMove("MidPoint", 0, Time[0], MidPoint);
   }
 
} // end start() 
[color=Red][b]}[/b][/color]

datetime eaExpirationTime;
string expiredString = "You are shit out of luck";


int init()
{
   eaExpirationTime = StrToTime("2009.2.10");

   return(0);
}


int start()
{
   //check for EA expiration
   if(IsTesting() == false){
      if(isEAExpired(eaExpirationTime) == true){
         Comment(expiredString);
         Print(expiredString);
         return(0);
      }
   }
   
   //now do the rest
}


bool isEAExpired(datetime expirationTime)
{
   if(TimeCurrent() > expirationTime){
      return(true);
   }else{
      return(false);
   }
} 

Quoting tdion

Disliked

ronald you are far more patient and helpful than i am.

Ignored