Art Phantom EA

i got worse results with this mod. it hit 0 balance.

if i allow hedged trade on B, then its working fine. i am going to reverse the changes

Oh, important are results so let's go.....

pl forward test and let me know how it works....

Sure......

Roundrock will you please edit art phantom light with pipstep for EU UC EC pairs.. I have tried 100 of times but ea never open pairs..
Please do it whenever you will be free... I want to forward test it.


Thanx in advance.

Regards
24hrs

Hi Roundrock,

I have noticed that with last version (with CLM mod) the EA doesn´t open any new trade after a few hours running. I had tested with 2 differents brokers, differents leverage, CLM: 1.0 and CLM: 2.0, CLCap: 100 and the same problem.

Any idea?

Thank you

For a new trade open, the Phantom trade must be some pips above or below "Phantom EA Start Price" or just above or below ?

Can anyone point me to Art_Phantom_light with trading hours? I have searched and searched but cannot find it

TIA

if its above or below start price it places orders. no other filter

Hi

Why not try the one at post 504

are you saying EA is not placing any new orders at all ? or it places some and then stops placing new orders ?

also pl copy paste the log statements from Experts tab. this gives usefule info

I have tested on 2 brokers, 400:1 and 200:1, after the first closure in one case and after 3 trades in the other, no more trades opened, really strange (no message on "experts tab").

I will try again.....

Art_phantom_light ( 4 pairs) has been running good in my demo since 7 th dec. Has closed five baskets since 7 th. Not much DD too. Max DD was 3.31 %

did you see this kind of messages ? also are you using any filters ? like UseTradingHours,....


2010.12.13 20:00:02 Single Pair Phantom EURUSD,M15: Adding a EURUSD short. current PL 0.00000000 Total orders so far: 1, longs: 0, shorts: 1, tickets: 38390549
2010.12.13 20:00:02 Single Pair Phantom EURUSD,M15: open #38390549 sell 0.10 EURUSD at 1.33120 ok
2010.12.13 20:00:00 Single Pair Phantom EURUSD,M15: Trying to add EURUSD short.
2010.12.13 19:56:03 Single Pair Phantom EURUSD,M15: ----------- resetting phantomStartPrice 1.33137000
2010.12.13 19:56:03 Single Pair Phantom EURUSD,M15: ------------------ Closed 5 trades
2010.12.13 19:56:03 Single Pair Phantom EURUSD,M15: close #38389905 buy 0.10 EURUSD at 1.33115 at price 1.33132
2010.12.13 19:56:03 Single Pair Phantom EURUSD,M15: ----------------- In full closure mode. Closing a EURUSD buy trade...
2010.12.13 19:56:03 Single Pair Phantom EURUSD,M15: ---- closing ticketNumber 38389905
2010.12.13 19:56:03 Single Pair Phantom EURUSD,M15: close #38385031 buy 0.10 EURUSD at 1.32977 at price 1.33132
2010.12.13 19:56:02 Single Pair Phantom EURUSD,M15: ----------------- In full closure mode. Closing a EURUSD buy trade...
2010.12.13 19:56:02 Single Pair Phantom EURUSD,M15: ---- closing ticketNumber 38385031
2010.12.13 19:56:02 Single Pair Phantom EURUSD,M15: close #38383916 buy 0.10 EURUSD at 1.32801 at price 1.33132
2010.12.13 19:56:02 Single Pair Phantom EURUSD,M15: ----------------- In full closure mode. Closing a EURUSD buy trade...
2010.12.13 19:56:02 Single Pair Phantom EURUSD,M15: ---- closing ticketNumber 38383916
2010.12.13 19:56:02 Single Pair Phantom EURUSD,M15: close #38382418 sell 0.10 EURUSD at 1.32681 at price 1.33146
2010.12.13 19:56:01 Single Pair Phantom EURUSD,M15: ------------------In full closure mode. Closing a EURUSD sell trade...
2010.12.13 19:56:01 Single Pair Phantom EURUSD,M15: ---- closing ticketNumber 38382418
2010.12.13 19:56:01 Single Pair Phantom EURUSD,M15: close #38377957 buy 0.10 EURUSD at 1.32788 at price 1.33137
2010.12.13 19:55:58 Single Pair Phantom EURUSD,M15: ----------------- In full closure mode. Closing a EURUSD buy trade...
2010.12.13 19:55:58 Single Pair Phantom EURUSD,M15: ---- closing ticketNumber 38377957
2010.12.13 19:55:58 Single Pair Phantom EURUSD,M15: @@@@@@@@@@@@@@@@ Pop # 2 ...... OrdersTotal to close 5 orderCount 5 ticketNumberString38377957 38382418 38383916 38385031 38389905

No other filters, only CLM: 1 and CLM: 2.....

Thank you Nicastro

//+------------------------------------------------------------------+
//| Art_Phantom_Full-Timings_&_Cut_Losers |
//+------------------------------------------------------------------+
/*
Attach to any chart, any timeframe. Do not attach to more than one
chart.

These are the pairs we trade:

For InterbankFX
---------------
Group 1, The Phantom Buys
6. EURCHF

Group 2, The Phantom Sells
7. EURUSD
8. USDCHF

Initially, buy the phantom buy group of pairs and sell the phantom-sell
group of pairs.

Every 30 min, add a real trade of every winning phantom pair if the pair is
EURCHF, EURUSD, USDCHF, but only if all previous trades for that pair
are winners.

Close all when current equity exceeds ProfitPct above last flat equity.

*/

//+------------------------------------------------------------------+
//| External Variables |
//+------------------------------------------------------------------+

extern bool Bailout = false;

extern int Slippage = 3;
extern int MiniSize = 10000;
extern int StdSize = 100000;


extern int EURCHFidx = 1;

extern int EURUSDidx = 2;
extern int USDCHFidx = 3;

extern int Sunday = 0;
extern int Monday = 1;
extern int Tuesday = 2;
extern int Wednesday = 3;
extern int Thursday = 4;
extern int Friday = 5;
extern int Saturday = 6;

extern bool UserTradingAllowed = true;
extern bool StopAfterNoTrades = false;
extern bool UseSmallestLot = false;

extern double MaxMarginToUse = 0.4; // Maximum percent of margin to commit to each trade.
extern double Lots = 0.1;
extern double ProfitPct = 1.0;
extern double MaxMiniProfit = 1000.0;
extern double MaxStdProfit = 10000.0;

/*** the-game START (Added) ***/
extern bool UsePipStep = true;
extern int PipStep = 10; // Pip Buffer before adding more trades to a pair
/*** the-game END (Added) ***/

/*** the-game START (Added) ***/
extern bool UseTradingHours = true;
extern int StartHour = 7;
extern int FinishHour = 19;
/*** the-game END (Added) ***/

/*** roundrock START (Added) ***/
extern bool CutLoserTrades = false;
extern double CutLoserMultiplier = 3;
/*** roundrock END (Added) ***/

extern int MagicNumber = 777111;


//+------------------------------------------------------------------+
//| Internal Variables |
//+------------------------------------------------------------------+

int i, j;
int OrderSendResult;
int Leverage;
int NumBuys, NumSells;
int TotalTrades;
int AccountTypeVal;

int EURCHFbuys, EURCHFsells;

int EURUSDbuys, EURUSDsells;
int USDCHFbuys, USDCHFsells;

bool AccountIsMini;
bool CloseNextLoser;
bool CloseAll;
bool BidsHaveChanged = false;
bool Group1LongGroup2Short, Group1ShortGroup2Long;

string AccountTypeString;
string LastFlatBal; double valLastFlatBal;
string LastFlatEq; double valLastFlatEq;
string LowestMarginLevel; double valLowestMarginLevel;
string LargestFloatingLoss; double valLargestFloatingLoss;
string MaxFloatingDrawdown; double valMaxFloatingDrawdown;

string EURCHFadded; bool valEURCHFadded;

string EURUSDadded; bool valEURUSDadded;
string USDCHFadded; bool valUSDCHFadded;

string EURCHFsym;

string EURUSDsym;
string USDCHFsym;

string CommentString;

string SymbolArray[14];

double MaxLots;
double MinLots;
double UseLots, TotalLots, BuyLots, SellLots;
double phantomEAPL, phantomBuyPL, phantomSellPL, PairOverallPL, EAPL, BuyPL, SellPL, EquityExit;
double PercentMarginLevel;
double DollarProfitTarget;
double MaxMarginVar;
double Investment;

// PL for real trades

double EURCHFPL;

double EURUSDPL;
double USDCHFPL;

// PL for phantom trades

double EURCHF_PL;

double EURUSD_PL;
double USDCHF_PL;

double prevEURCHFbid = 0.0;

double prevEURUSDbid = 0.0;
double prevUSDCHFbid = 0.0;

double BiggestWinnerPL;
double BiggestWinnerLots;
int BiggestWinnerTicket;
string BiggestWinnerType;
string BiggestWinnerSymbol;

double BiggestLoserPL;
double BiggestLoserLots;
int BiggestLoserTicket;
string BiggestLoserType;
string BiggestLoserSymbol;

double BiggestPhantomWinnerPL;
string BiggestPhantomWinnerType;
string BiggestPhantomWinnerSymbol;

string strEURCHFask; double EURCHFask = 0.0, EURJPYpoint, EURCHFtickval;

string strEURUSDbid; double EURUSDbid = 0.0, EURUSDpoint, EURUSDtickval;
string strUSDCHFbid; double USDCHFbid = 0.0, USDJPYpoint, USDCHFtickval;

double PL_Array[3];
double TickvalArray[3];

//+------------------------------------------------------------------+
//| Expert Advisor Initialization, executes only when the EA is |
//| first attached to a chart or on platform restart. |
//+------------------------------------------------------------------+

int init()
{
SetSymbols();
SetGlobalVariableNames();
InitGlobalVars();

/*** the-game START (Added) ***/
if (UsePipStep && (Digits == 3 || Digits == 5)) PipStep = PipStep * 10;
/*** the-game END (Added) ***/

return (0);
}

//+------------------------------------------------------------------+
//| Expert Advisor start function, executes on each tick of the |
//| currecy pair it's attached to. |
//+------------------------------------------------------------------+

int start()
{
if (Bailout || (!IsTesting() && !IsExpertEnabled()))
{
Comment("Expert is not enabled");

return(0);
}

RefreshGlobalVars();
GetAccountInfo();

SetAccountType();
SetLotSize();
Count_PL_Trades_Lots();
SetExitTargets();

BidsHaveChanged =

prevEURCHFbid != 0.0 &&

prevEURUSDbid != 0.0 &&
prevUSDCHFbid != 0.0 &&

(
prevEURCHFbid != MarketInfo(EURCHFsym, MODE_BID) ||
prevEURUSDbid != MarketInfo(EURUSDsym, MODE_BID) ||
prevUSDCHFbid != MarketInfo(USDCHFsym, MODE_BID));

/*** the-game START (Added) ***/
if (UseTradingHours)
{
if (TimeHour(TimeCurrent()) >= StartHour &&
((TimeHour(TimeCurrent()) < FinishHour && FinishHour != 0) ||
(TimeHour(TimeCurrent()) < 24 && FinishHour == 0)))
{
if (StopAfterNoTrades && TotalTrades == 0) ResetPhantoms();
StopAfterNoTrades = false;
}
else
{
StopAfterNoTrades = true;
}
}
/*** the-game END (Added) ***/

/*** roundrock START (Added) ***/
if (CutLoserTrades) CloseLoserTradesIfNeeded();
/*** roundrock END (Added) ***/

/*** the-game START (Modified) ***/
CloseAllTradesIfNeeded();

if (TotalTrades == 0)
{
if (AccountBalance() > valLastFlatBal)
{
valLastFlatBal = AccountBalance();
GlobalVariableSet(LastFlatBal, valLastFlatBal);
}

if (AccountEquity() > valLastFlatEq)
{
valLastFlatEq = AccountEquity();
GlobalVariableSet(LastFlatEq, valLastFlatEq);
}

if (!IsExpertEnabled() || StopAfterNoTrades)
{
PrintChartComments();
return(0);
}

CloseAll = false;
}

if (!CloseAll && valLastFlatEq != 0.0 && AccountEquity()-valLastFlatEq > DollarProfitTarget)
{
CloseAll = true;
ResetPhantoms();

return(0);
}

OpenPhantomTrades();
CalcPhantomPL();
AddIfNeeded();
/*** the-game END (Modified) ***/

ExamineMarginAndFloat();

prevEURCHFbid = MarketInfo(EURCHFsym, MODE_BID);

prevEURUSDbid = MarketInfo(EURUSDsym, MODE_BID);
prevUSDCHFbid = MarketInfo(USDCHFsym, MODE_BID);

PrintChartComments();

return(0);
}

//+------------------------------------------------------------------+
//| Assign values to global variable namestrings. |
//+------------------------------------------------------------------+

void SetGlobalVariableNames()
{
LowestMarginLevel = MagicNumber+"_LowestMarginLevel";
LargestFloatingLoss = MagicNumber+"_LargestFloatingLoss";
MaxFloatingDrawdown = MagicNumber+"_MaxFloatingDrawdown";

LastFlatBal = MagicNumber+"_LastFlatBal";
LastFlatEq = MagicNumber+"_LastFlatEq";

EURCHFadded = MagicNumber+"_EURCHFadded";

EURUSDadded = MagicNumber+"_EURUSDadded";
USDCHFadded = MagicNumber+"_USDCHFadded";

strEURCHFask = MagicNumber+"_"+EURCHFsym;

strEURUSDbid = MagicNumber+"_"+EURUSDsym;
strUSDCHFbid = MagicNumber+"_"+USDCHFsym;

return(0);
}

//+------------------------------------------------------------------+
//| Assign initial values to global variables. |
//+------------------------------------------------------------------+

void InitGlobalVars()
{
if (!GlobalVariableCheck(LowestMarginLevel)) GlobalVariableSet(LowestMarginLevel, 100000000.0);
if (!GlobalVariableCheck(LargestFloatingLoss)) GlobalVariableSet(LargestFloatingLoss, 0.0);
if (!GlobalVariableCheck(MaxFloatingDrawdown)) GlobalVariableSet(MaxFloatingDrawdown, 0.0);

if (!GlobalVariableCheck(LastFlatBal)) GlobalVariableSet(LastFlatBal, AccountBalance());
if (!GlobalVariableCheck(LastFlatEq)) GlobalVariableSet(LastFlatEq, AccountEquity());

if (!GlobalVariableCheck(EURCHFadded)) GlobalVariableSet(EURCHFadded, false);

if (!GlobalVariableCheck(EURUSDadded)) GlobalVariableSet(EURUSDadded, false);
if (!GlobalVariableCheck(USDCHFadded)) GlobalVariableSet(USDCHFadded, false);

if (!GlobalVariableCheck(strEURCHFask)) GlobalVariableSet(strEURCHFask, EURCHFask);

if (!GlobalVariableCheck(strEURUSDbid)) GlobalVariableSet(strEURUSDbid, EURUSDbid);
if (!GlobalVariableCheck(strUSDCHFbid)) GlobalVariableSet(strUSDCHFbid, USDCHFbid);


return(0);
}

//+------------------------------------------------------------------+
//| Get global variable values via their namestring and assign the |
//| stored values to the variables used in the EA's logic. |
//+------------------------------------------------------------------+

void RefreshGlobalVars()
{
valLowestMarginLevel = GlobalVariableGet(LowestMarginLevel);
valLargestFloatingLoss = GlobalVariableGet(LargestFloatingLoss);
valMaxFloatingDrawdown = GlobalVariableGet(MaxFloatingDrawdown);

valLastFlatBal = GlobalVariableGet(LastFlatBal);
valLastFlatEq = GlobalVariableGet(LastFlatEq);

valEURCHFadded = GlobalVariableGet(EURCHFadded);

valEURUSDadded = GlobalVariableGet(EURUSDadded);
valUSDCHFadded = GlobalVariableGet(USDCHFadded);

EURCHFask = GlobalVariableGet(strEURCHFask);

EURUSDbid = GlobalVariableGet(strEURUSDbid);
USDCHFbid = GlobalVariableGet(strUSDCHFbid);


return(0);
}

//+------------------------------------------------------------------+
//| Get important account parameters that affect how the lot size |
//| will be set. |
//+------------------------------------------------------------------+

void GetAccountInfo()
{
// Get account leverage, account type.
Leverage = AccountLeverage();

AccountTypeVal = MarketInfo(Symbol(), MODE_LOTSIZE);
MaxLots = MarketInfo(Symbol(), MODE_MAXLOT);
MinLots = MarketInfo(Symbol(), MODE_MINLOT);

return(0);
}

//+------------------------------------------------------------------+
//| Set the traded symbol strings. |
//+------------------------------------------------------------------+

void SetSymbols()
{
string AddMangle = "";
if (StringLen(Symbol()) > 6) AddMangle = StringSubstr(Symbol(), 6);

EURCHFsym = "EURCHF" + AddMangle;

EURUSDsym = "EURUSD" + AddMangle;
USDCHFsym = "USDCHF" + AddMangle;

SymbolArray[EURCHFidx] = EURCHFsym;

SymbolArray[EURUSDidx] = EURUSDsym;
SymbolArray[USDCHFidx] = USDCHFsym;

return(0);
}

//+------------------------------------------------------------------+
//| Reset the phantom trades. |
//+------------------------------------------------------------------+

void ResetPhantoms()
{
EURCHFask = 0.0;

EURUSDbid = 0.0;
USDCHFbid = 0.0;

GlobalVariableSet(strEURCHFask, EURCHFask);

GlobalVariableSet(strEURUSDbid, EURUSDbid);
GlobalVariableSet(strUSDCHFbid, USDCHFbid);

return(0);
}

//+------------------------------------------------------------------+
//| Open phantom trades. |
//+------------------------------------------------------------------+

void OpenPhantomTrades()
{
if (EURCHFask == 0.0 &&

EURUSDbid == 0.0 && USDCHFbid == 0.0)
{
EURCHFask = MarketInfo(EURCHFsym, MODE_ASK);

EURUSDbid = MarketInfo(EURUSDsym, MODE_BID);
USDCHFbid = MarketInfo(USDCHFsym, MODE_BID);

GlobalVariableSet(strEURCHFask, EURCHFask);

GlobalVariableSet(strEURUSDbid, EURUSDbid);
GlobalVariableSet(strUSDCHFbid, USDCHFbid);
}

return(0);
}

//+------------------------------------------------------------------+
//| Set the account type and minimum equity. |
//+------------------------------------------------------------------+

void SetAccountType()
{
if (AccountTypeVal == MiniSize || StringLen(Symbol()) == 7)
{
AccountIsMini = true;
AccountTypeString = "MINI";
}
else if (AccountTypeVal == StdSize || StringLen(Symbol()) == 6)
{
AccountIsMini = false;
AccountTypeString = "STANDARD";
}

return(0);
}

//+------------------------------------------------------------------+
//| Set the lot size for any trades. |
//+------------------------------------------------------------------+

void SetLotSize()
{
Investment = MaxMarginToUse / 100.0;

// The symbol the EA is attached to should be good enough for the purposes of LOTSIZE
UseLots = valLastFlatEq * Investment * (Leverage / MarketInfo(Symbol(), MODE_LOTSIZE));
UseLots = StrToDouble(DoubleToStr(UseLots,2));

if (UseSmallestLot || UseLots < MinLots) UseLots = MinLots;
if (UseLots > MaxLots) UseLots = MaxLots;

return(0);
}

//+------------------------------------------------------------------+
//| Do some accounting -- count the profit/loss, the open trades, |
//| and the number of open lots. |
//+------------------------------------------------------------------+

void Count_PL_Trades_Lots()
{
NumBuys = 0;
NumSells = 0;
TotalTrades = 0;
EAPL = 0.0;
BuyPL = 0.0;
SellPL = 0.0;
TotalLots = 0.0;
BuyLots = 0.0;
SellLots = 0.0;

EURCHFbuys = 0; EURCHFsells = 0;

EURUSDbuys = 0; EURUSDsells = 0;
USDCHFbuys = 0; USDCHFsells = 0;

BiggestWinnerPL = 0.0;
BiggestWinnerLots = 0.0;
BiggestWinnerTicket = 0;
BiggestWinnerType = "";
BiggestWinnerSymbol = "";

BiggestLoserPL = 0.0;
BiggestLoserLots = 0.0;
BiggestLoserTicket = 0;
BiggestLoserType = "";
BiggestLoserSymbol = "";

for (i = 0; i < OrdersTotal(); i++)
{
OrderSelect(i,SELECT_BY_POS,MODE_TRADES);

if (OrderMagicNumber() == MagicNumber)
{
PairOverallPL = OrderProfit() + OrderSwap() + OrderCommission();
EAPL += PairOverallPL;
TotalLots += OrderLots();

if (OrderType() == OP_BUY)
{
BuyPL += PairOverallPL;

if (PairOverallPL > BiggestWinnerPL)
{
BiggestWinnerPL = PairOverallPL;
BiggestWinnerLots = OrderLots();
BiggestWinnerTicket = OrderTicket();
BiggestWinnerType = "BUY";
BiggestWinnerSymbol = OrderSymbol();
}

if (PairOverallPL < BiggestLoserPL)
{
BiggestLoserPL = PairOverallPL;
BiggestLoserLots = OrderLots();
BiggestLoserTicket = OrderTicket();
BiggestLoserType = "BUY";
BiggestLoserSymbol = OrderSymbol();
}

BuyLots += OrderLots();

NumBuys++;

if (OrderSymbol() == EURCHFsym) { EURCHFbuys++; EURCHFPL = PairOverallPL; }
else
if (OrderSymbol() == EURUSDsym) { EURUSDbuys++; EURUSDPL = PairOverallPL; }
else
if (OrderSymbol() == USDCHFsym) { USDCHFbuys++; USDCHFPL = PairOverallPL; }
else
}

if (OrderType() == OP_SELL)
{
SellPL += PairOverallPL;

if (PairOverallPL> BiggestWinnerPL)
{
BiggestWinnerPL = PairOverallPL;
BiggestWinnerLots = OrderLots();
BiggestWinnerTicket = OrderTicket();
BiggestWinnerType = "SELL";
BiggestWinnerSymbol = OrderSymbol();
}

if (PairOverallPL< BiggestLoserPL)
{
BiggestLoserPL = PairOverallPL;
BiggestLoserLots = OrderLots();
BiggestLoserTicket = OrderTicket();
BiggestLoserType = "SELL";
BiggestLoserSymbol = OrderSymbol();
}

SellLots += OrderLots();

NumSells++;

if (OrderSymbol() == EURCHFsym) { EURCHFsells++; EURCHFPL = PairOverallPL; }
else
if (OrderSymbol() == EURUSDsym) { EURUSDsells++; EURUSDPL = PairOverallPL; }
else
if (OrderSymbol() == USDCHFsym) { USDCHFsells++; USDCHFPL = PairOverallPL; }
else
}
}
}
TotalTrades = NumBuys+NumSells;

return(0);
}

//+------------------------------------------------------------------+
//| Set the dollar profit and trim target values. |
//+------------------------------------------------------------------+

void SetExitTargets()
{
DollarProfitTarget = StrToDouble(DoubleToStr(valLastFlatEq*ProfitPct/100.0,2));

if (AccountIsMini)
{
if (DollarProfitTarget > MaxMiniProfit) DollarProfitTarget = MaxMiniProfit;
}
else
{
if (DollarProfitTarget > MaxStdProfit) DollarProfitTarget = MaxStdProfit;
}

return(0);
}

/*** roundrock START (Added) ***/
//+------------------------------------------------------------------+
//| Close loser trades that exceed a multiplier of dollar profit |
//+------------------------------------------------------------------+

void CloseLoserTradesIfNeeded()
{
if (BidsHaveChanged)
{
for(i = 0; i < OrdersTotal(); i++)
{
OrderSelect(i,SELECT_BY_POS,MODE_TRADES);

if (OrderMagicNumber() == MagicNumber && OrderProfit()<0 && (MathAbs(OrderProfit()) >= DollarProfitTarget*CutLoserMultiplier))
{
if (OrderType() == OP_BUY)
{
Comment("Cutting loser trade. Closing a ", OrderSymbol(), " buy trade...");
Print("Cutting loser trade. Closing a ", OrderSymbol(), " buy trade...");
OrderClose(OrderTicket(),OrderLots(),MarketInfo(OrderSymbol(), MODE_BID),Slippage,White);
Sleep(1000);
}
else
if (OrderType() == OP_SELL)
{
Comment("Cutting loser trade. Closing a ", OrderSymbol(), " sell trade...");
Print("Cutting loser trade. Closing a ", OrderSymbol(), " sell trade...");
OrderClose(OrderTicket(),OrderLots(),MarketInfo(OrderSymbol(), MODE_ASK),Slippage,White);
Sleep(1000);
}
}
}
}

return(0);
}
/*** roundrock END (Added) ***/

//+------------------------------------------------------------------+
//| Close all of the open trades. |
//+------------------------------------------------------------------+

void CloseAllTradesIfNeeded()
{
if (BidsHaveChanged && CloseAll)
{
for(i = 0; i < OrdersTotal(); i++)
{
OrderSelect(i,SELECT_BY_POS,MODE_TRADES);

if (OrderMagicNumber() == MagicNumber)
{
if (OrderType() == OP_BUY)
{
Comment("In full closure mode. Closing a ", OrderSymbol(), " buy trade...");
Print("In full closure mode. Closing a ", OrderSymbol(), " buy trade...");
OrderClose(OrderTicket(),OrderLots(),MarketInfo(OrderSymbol(), MODE_BID),Slippage,White);
Sleep(1000);
}
else
if (OrderType() == OP_SELL)
{
Comment("In full closure mode. Closing a ", OrderSymbol(), " sell trade...");
Print("In full closure mode. Closing a ", OrderSymbol(), " sell trade...");
OrderClose(OrderTicket(),OrderLots(),MarketInfo(OrderSymbol(), MODE_ASK),Slippage,White);
Sleep(1000);
}
}
}
}

return(0);
}

//+------------------------------------------------------------------+
//| Clear all symbol-added marks. |
//+------------------------------------------------------------------+

void ClearSymbolMarks()
{

valEURCHFadded = false;
GlobalVariableSet(EURCHFadded, valEURCHFadded);

valEURUSDadded = false;
GlobalVariableSet(EURUSDadded, valEURUSDadded);

valUSDCHFadded = false;
GlobalVariableSet(USDCHFadded, valUSDCHFadded);

return(0);
}

//+------------------------------------------------------------------+
//| Mark the given currency pair as added. |
//+------------------------------------------------------------------+

void MarkSymbolAdded(string theSymbol)
{
if (theSymbol == EURCHFsym)
{
valEURCHFadded = true;
GlobalVariableSet(EURCHFadded, valEURCHFadded);
}
else
if (theSymbol == EURUSDsym)
{
valEURUSDadded = true;
GlobalVariableSet(EURUSDadded, valEURUSDadded);
}
else
if (theSymbol == USDCHFsym)
{
valUSDCHFadded = true;
GlobalVariableSet(USDCHFadded, valUSDCHFadded);
}

return(0);
}

//+------------------------------------------------------------------+
//| Check if the given currency is marked as added. |
//+------------------------------------------------------------------+

bool SymbolMarked(string theSymbol)
{

if (theSymbol == EURCHFsym && valEURCHFadded)
{
return(true);
}
else
if (theSymbol == EURUSDsym && valEURUSDadded)
{
return(true);
}
else
if (theSymbol == USDCHFsym && valUSDCHFadded)
{
return(true);
}

return(false);
}

//+------------------------------------------------------------------+
//| Correct problem of brokers using 3 or 5 digit pricing |
//+------------------------------------------------------------------+

double SetPoint(string theSymbol)
{
double mPoint, mDigits;

mDigits = MarketInfo(theSymbol, MODE_DIGITS);

if (mDigits < 4)
mPoint = 0.01;
else
mPoint = 0.0001;

return(mPoint);
}

//+------------------------------------------------------------------+
//| Correct problem of brokers using 3 or 5 digit pricing |
//+------------------------------------------------------------------+

double SetTickValue(string theSymbol, double thePoint)
{
double mTickValue;

if (thePoint/10.0 == MarketInfo(theSymbol, MODE_POINT))
{
mTickValue = MarketInfo(theSymbol, MODE_TICKVALUE)*10.0;
}
else // if (thePoint == MarketInfo(theSymbol, MODE_POINT))
{
mTickValue = MarketInfo(theSymbol, MODE_TICKVALUE);
}

return(mTickValue);
}

//+------------------------------------------------------------------+
//| Set the value of Point for each pair. |
//+------------------------------------------------------------------+

void SetPointsAndTickvalues()
{
EURCHFpoint = SetPoint(EURCHFsym);

EURUSDpoint = SetPoint(EURUSDsym);
USDCHFpoint = SetPoint(USDCHFsym);

EURCHFtickval = SetTickValue(EURCHFsym, EURCHFpoint);
TickvalArray[EURCHFidx] = EURCHFtickval;

EURUSDtickval = SetTickValue(EURUSDsym, EURUSDpoint);
TickvalArray[EURUSDidx] = EURUSDtickval;

USDCHFtickval = SetTickValue(USDCHFsym, USDCHFpoint);
TickvalArray[USDCHFidx] = USDCHFtickval;


return(0);
}

//+------------------------------------------------------------------+
//| Calculate PL for phantom trades. |
//+------------------------------------------------------------------+

void CalcPhantomPL()
{
SetPointsAndTickvalues();

if (EURCHFpoint != 0.0)
{
EURCHF_PL = (MarketInfo(EURCHFsym, MODE_BID) - EURCHFask) / EURCHFpoint;
EURCHF_PL *= TickvalArray[EURCHFidx]*UseLots;
PL_Array[EURCHFidx] = EURCHF_PL;
}

phantomBuyPL = EURCHF_PL;

if (EURUSDpoint != 0.0)
{
EURUSD_PL = (EURUSDbid - MarketInfo(EURUSDsym, MODE_ASK)) / EURUSDpoint;
EURUSD_PL *= TickvalArray[EURUSDidx]*UseLots;
PL_Array[EURUSDidx] = EURUSD_PL;
}

if (USDCHFpoint != 0.0)
{
USDCHF_PL = (USDCHFbid - MarketInfo(USDCHFsym, MODE_ASK)) / USDCHFpoint;
USDCHF_PL *= TickvalArray[USDCHFidx]*UseLots;
PL_Array[USDCHFidx] = USDCHF_PL;
}

phantomSellPL = EURUSD_PL + USDCHF_PL;
phantomEAPL = phantomBuyPL + phantomSellPL;

// Determine biggest phantom winner.

BiggestPhantomWinnerPL = 0.0;
BiggestPhantomWinnerType = "";
BiggestPhantomWinnerSymbol = "";


if (EURCHF_PL > BiggestPhantomWinnerPL)
{
BiggestPhantomWinnerPL = EURCHF_PL;
BiggestPhantomWinnerType = "BUY";
BiggestPhantomWinnerSymbol = EURCHFsym;
}


if (EURUSD_PL > BiggestPhantomWinnerPL)
{
BiggestPhantomWinnerPL = EURUSD_PL;
BiggestPhantomWinnerType = "SELL";
BiggestPhantomWinnerSymbol = EURUSDsym;
}
if (USDCHF_PL > BiggestPhantomWinnerPL)
{
BiggestPhantomWinnerPL = USDCHF_PL;
BiggestPhantomWinnerType = "SELL";
BiggestPhantomWinnerSymbol = USDCHFsym;
}

return(0);
}

//+------------------------------------------------------------------+
//| Check if all symbol trades in profit. |
//+------------------------------------------------------------------+

bool AllSymbolTradesInProfit(string theSymbol)
{
for (j = 0; j < OrdersTotal(); j++)
{
OrderSelect(j,SELECT_BY_POS,MODE_TRADES);

/*** the-game START (Modified) ***/
if (OrderMagicNumber() == MagicNumber &&
OrderSymbol() == theSymbol)
{
if (UsePipStep)
{
if (OrderType() == OP_BUY && (MarketInfo(OrderSymbol(), MODE_BID) - OrderOpenPrice()) < PipStep * MarketInfo(OrderSymbol(), MODE_POINT)) return(false);
if (OrderType() == OP_SELL && (OrderOpenPrice() - MarketInfo(OrderSymbol(), MODE_ASK)) < PipStep * MarketInfo(OrderSymbol(), MODE_POINT)) return(false);
}
else
{
if (OrderProfit() <= 0.0) return(false);
}
}
/*** the-game END (Modified) ***/
}

return(true);
}

//+------------------------------------------------------------------+
//| Add to winning trades. |
//+------------------------------------------------------------------+

void AddIfNeeded()
{
if (TimeMinute(TimeCurrent()) != 15 && TimeMinute(TimeCurrent()) != 45) ClearSymbolMarks();

if ((BidsHaveChanged &&
(TimeMinute(TimeCurrent()) == 15 || TimeMinute(TimeCurrent()) == 45) &&
!CloseAll))
{
for (i = EURCHFidx; i <= USDCHFidx; i++)
{
if (PL_Array[i] > 0.0 &&
(SymbolArray[i] == EURCHFsym || SymbolArray[i] == EURUSDsym || SymbolArray[i] == USDCHFsym) &&
!SymbolMarked(SymbolArray[i]))
{
if (AllSymbolTradesInProfit(SymbolArray[i]) &&
!SymbolMarked(SymbolArray[i]))
{
if (i < 2)
{
Comment("Adding a " + SymbolArray[i] + " buy trade...");
Print("Adding a " + SymbolArray[i] + " long.");
OrderSendResult = OrderSend(SymbolArray[i],OP_BUY,UseLots,MarketInfo(SymbolArray[i], MODE_ASK),
Slippage,0,0,"Adding to a long phantom winner",MagicNumber,Blue);
if (OrderSendResult > 0) MarkSymbolAdded(SymbolArray[i]);
Sleep(1000);
}
else
// if (i >= 7)
{
Comment("Adding a " + SymbolArray[i] + " sell trade...");
Print("Adding a " + SymbolArray[i] + " short.");
OrderSendResult = OrderSend(SymbolArray[i],OP_SELL,UseLots,MarketInfo(SymbolArray[i], MODE_BID),
Slippage,0,0,"Adding to a short phantom winner",MagicNumber,Red);
if (OrderSendResult > 0) MarkSymbolAdded(SymbolArray[i]);
Sleep(1000);
}
}
}
}
}

return(0);
}

//+------------------------------------------------------------------+
//| Keep track of lowest margin level and largest floating loss. |
//+------------------------------------------------------------------+

void ExamineMarginAndFloat()
{
if (AccountMargin() > 0.0)
{
PercentMarginLevel = StrToDouble(DoubleToStr(100 * AccountEquity() / AccountMargin(), 2));

if (PercentMarginLevel < valLowestMarginLevel)
{
valLowestMarginLevel = PercentMarginLevel;
GlobalVariableSet(LowestMarginLevel, valLowestMarginLevel);
}
}

if (EAPL < valLargestFloatingLoss)
{
valLargestFloatingLoss = StrToDouble(DoubleToStr(EAPL, 2));
GlobalVariableSet(LargestFloatingLoss, valLargestFloatingLoss);
}

if ((valLargestFloatingLoss / valLastFlatEq) * 100.0 < valMaxFloatingDrawdown)
{
valMaxFloatingDrawdown = StrToDouble(DoubleToStr((valLargestFloatingLoss / valLastFlatEq) * 100.0, 2));
GlobalVariableSet(MaxFloatingDrawdown, valMaxFloatingDrawdown);
}

return(0);
}

//+------------------------------------------------------------------+
//| Print Info to Chart |
//+------------------------------------------------------------------+

void PrintChartComments()
{
CommentString =
"STRATEGY: Every 30 min, at 15 and 45, add a trade to every winning EURJPY, EURUSD, USDJPY phantom," +
"nbut only if all previous trades are winners. Close all when current equity exceeds ProfitPct above last flat equity." +
"nnREMINDER: Be FLAT (all trades closed) before depositing/withdrawing funds." +
"nnAccount Type: " + AccountTypeString + " Account, Leverage: " + DoubleToStr(Leverage,0) + ":1" +
", Margin %: " + DoubleToStr(PercentMarginLevel,2) + "%, Lowest Margin %: " + DoubleToStr(valLowestMarginLevel,2) + "%" +
"nLargest Floating Loss: $" + DoubleToStr(valLargestFloatingLoss,2) + ", Max Floating Drawdown %: " + DoubleToStr(valMaxFloatingDrawdown,2) + "%" +
"nBalance: $" + DoubleToStr(AccountBalance(),2) + ", Equity: $" + DoubleToStr(AccountEquity(),2) +
"nLast Flat Balance: $" + DoubleToStr(valLastFlatBal,2) + ", Last Flat Equity: $" + DoubleToStr(valLastFlatEq,2) +
"nDollar Profit Target: $" + DoubleToStr(DollarProfitTarget,2) + ", Equity Profit Target: $" + DoubleToStr(valLastFlatEq+DollarProfitTarget,2) +
"nOpen Buys: " + DoubleToStr(NumBuys,0) + ", Open Sells: " + DoubleToStr(NumSells,0) + ", Total Open Trades: " + DoubleToStr(TotalTrades,0) +
"nEURCHF Phantom PL: $" + DoubleToStr(EURCHF_PL,2) +
"nEURUSD Phantom PL: $" + DoubleToStr(EURUSD_PL,2) +
"nUSDCHF Phantom PL: $" + DoubleToStr(USDCHF_PL,2) +
"nPhantom Buy PL: $" + DoubleToStr(phantomBuyPL,2) + ", Phantom Sell PL: $" + DoubleToStr(phantomSellPL,2) + " Overall Phantom PL: $" + DoubleToStr(phantomEAPL,2) +
"nEA PL: $" + DoubleToStr(EAPL,2) + ", Buy PL: $" + DoubleToStr(BuyPL,2) + ", Sell PL: $" + DoubleToStr(SellPL,2) +
"nBiggest Winner Symbol: " + BiggestWinnerSymbol + ", Biggest Winner Type: " + BiggestWinnerType + ", Biggest Winner Ticket: " + DoubleToStr(BiggestWinnerTicket,0) + ", Biggest Winner PL: $" + DoubleToStr(BiggestWinnerPL,2) +
"nBiggest Loser Symbol: " + BiggestLoserSymbol + ", Biggest Loser Type: " + BiggestLoserType + ", Biggest Loser Ticket: " + DoubleToStr(BiggestLoserTicket,0) + ", Biggest Loser PL: $" + DoubleToStr(BiggestLoserPL,2);

/*** the-game START (Added) ***/
if (UseTradingHours && !StopAfterNoTrades)
CommentString = CommentString +
"nnCURRENTLY INSIDE TRADING HOURS (Start: " + StartHour + " - Finish: " + FinishHour + ")";

if (UseTradingHours && StopAfterNoTrades)
CommentString = CommentString +
"nnOUTSIDE OF TRADING HOURS (Start: " + StartHour + " - Finish: " + FinishHour + ")" +
"nI will not initiate a new set of trades, BUT I will continue with any existing set of trades.";

if (!UseTradingHours && StopAfterNoTrades)
CommentString = CommentString +
"nnStop After No Trades is set to TRUE" +
"nI will not initiate a new set of trades, BUT I will continue with any existing set of trades.";
/*** the-game END (Added) ***/

Comment(CommentString);

return(0);
}

Well I am testing above ea for EU UJ EJ from last Monday... and glad to say that it has just closed last basket after 3 days (ie after Thursday)
It has really outperformed. Max no of trades are limited to 12

But I want to test this for EU UC and EC.. I am sure it will do well!

Regards
24hrs.

Which EA you are talking about? Can you give me the link for download? Thanks.