//+------------------------------------------------------------------+
//| Breakdowning martingail™ v 1.0.2.mq4 |
//| Copyright © 2006, B@ss & Steve |
//| albass@mail333.com |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2006, B@ss & Steve"
#property link "albass@mail333.com, http://forum.alpari-idc.ru"
//----
#include <stdlib.mqh>
// åñëè false, òî ïðè çàêðûòèè òåêóùåé ñåðèè, íîâûå îðäåðà íå áóäóò îòêðûâàòüñÿ
extern bool TradeAllowed = true;
//øàã â ïóíêòàõ óðîâíåé
extern int Step = 18;
extern string _ = "Ïàðàìåòðû MoneyManagement";
// ðàçìåð òîðãóåìîãî ëîòà, ïðè âûêëþ÷åííîì ÌÌ
extern double startLots = 0.1;
// âêëþ÷åíèå MoneyManagement
extern bool MoneyManagement = true;
// ëîãàðèôìè÷åñêèé MoneyManagement
extern bool LogariphmicMM = true;
// ðàçìåð ëîòà â ïðîöåíòàõ îò äåïîçèòà
extern double Riskfactor = 6;
// ðàçìåð íóæíîãî ïðîôèòà â ïðîöåíòàõ îò äåïîçèòà
extern double ProfitPercent = 2;
// âêëþ÷åíèå îïòèìàëüíîãî çàêðûòèÿ îðäåðîâ (ïîâûøàåò äîõîäíîñòü)
extern bool OptimalTakeProfit = true;
extern string __ = "Ïàðàìåòðû ðàáîòû ýêñïåðòà";
// ðåæèì ðàáîòû ýêñïåðòà (0 - ïðîáîéíûé ñ âîçìîæíîñòüþ ñòàâèòü èíâåðñíûå îðäåðà,
// 1 - îòáîéíûé, ñ ïåðåìåùåíèåì îòëîæåííûõ ëèìèòíûõ îðäåðîâ)
extern int mode_work = 0;
// òðåéëèíã-ñòîï äëÿ ïëå÷à, âûøåäøåãî â ïðèáûëü (åñëè 0, òîãäà îòñóòñòâóåò)
extern int TrailingStop = 30;
//íå òîðãîâàòü ïîñëå çàêðûòèÿ ñåðèè äî ñëåäóþùåãî äíÿ
extern bool NoTradeBeforeNewDay = true;
// Ðåæèì èçìåíåíèÿ øàãà Step
// 0 - âñåãäà ðàâåí Step
// 1 - ïåðâûé øàã 15, âñå îñòàëüíûå 40
// 2 - ïëàâíî ìåíÿåòñÿ ñ óìåíüøåíèåì FreeMargin îò 15 äî 40
extern int MinMaxStepMode = 0;
//ïîêàçûâàòü ñëóæåáíóþ èíôîðìàöèþ ïî îðäåðàì â æóðíàëå òåðìèíàëà
extern bool ShowLog = false;
//----
int timeOut = 5000;
int maxLevel = 9; //ìàêñèìàëüíûé îòêðûòûé óðîâåíü
double LotsLevel_2 = 1; //øàã ïðèðàùåíèÿ ëîòîâ ñ óâåëè÷åíèåì óðîâíÿ
double LotsLevel_3 = 2;
double LotsLevel_4 = 4;
double LotsLevel_5 = 6;
double LotsLevel_6 = 10;
double LotsLevel_7 = 16;
double LotsLevel_8 = 26;
double LotsLevel_9 = 42;
double LotsLevel_10 = 64;
double LotsLevel_11 = 100;
double LotsLevel_12 = 168;
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
int init()
{
ObjectCreate("label_object", OBJ_LABEL, 0, 0, 0);
ObjectCreate("label_object1", OBJ_LABEL, 0, 0, 0);
ObjectCreate("label_object2", OBJ_LABEL, 0, 0, 0);
ObjectSet("label_object", OBJPROP_XDISTANCE, 11);
ObjectSet("label_object", OBJPROP_YDISTANCE, 14);
ObjectSet("label_object1", OBJPROP_XDISTANCE, 400);
ObjectSet("label_object1", OBJPROP_YDISTANCE, 20);
ObjectSet("label_object2", OBJPROP_XDISTANCE, 400);
ObjectSet("label_object2", OBJPROP_YDISTANCE, 35);
ObjectSetText("label_object", "Breakdowning Martingail™ version 1.0.2",
11, "Verdana", White);
return(0);
}
//+------------------------------------------------------------------+
//| Ôóíêöèÿ ïðîâåðÿåò íàëè÷èå îðäåðà ñ äàííûì ìàãè÷åñêèì íîìåðîì |
//+------------------------------------------------------------------+
bool isMgNum(int num)
{
int t, cnt1;
t = OrdersTotal();
for(cnt1 = 0; cnt1 < t; cnt1++)
{
OrderSelect(cnt1, SELECT_BY_POS, MODE_TRADES);
if(OrderMagicNumber() == num && OrderSymbol() == Symbol())
{
return(True);// âîçâðàùàåìîå çíà÷åíèå
}
}
return (False);
}
//+------------------------------------------------------------------+
//| Ôóíêöèÿ óäàëåíèÿ îðäåðà ïî ìàãè÷åñêîìó íîìåðó |
//+------------------------------------------------------------------+
bool deleteOrderNum(int num)
{
int t, cnt1, err;
bool tic;
t = OrdersTotal();
for(cnt1 = 0; cnt1 < t; cnt1++)
{
OrderSelect(cnt1, SELECT_BY_POS, MODE_TRADES);
if(OrderSymbol() == Symbol())
{
//òîëüêî äëÿ äàííîãî èíñòðóìåíòà
if(OrderMagicNumber() == num && (OrderType() == OP_BUYSTOP ||
OrderType() == OP_SELLSTOP || OrderType() == OP_SELLLIMIT ||
OrderType() == OP_BUYLIMIT))
{
int start = GetTickCount();
tic = OrderDelete(OrderTicket());
if(ShowLog)
{
Print("Âðåìÿ óäàëåíèÿ ", (GetTickCount() - start) / 1000, " ñåêóíä.");
}
if(tic)
PlaySound("timeout.wav");
if(!tic)
{
err = GetLastError();
Print("Îøèáêà = ", err, " (", ErrorDescription(err), ")");
}
return(True); // âîçâðàùàåìîå çíà÷åíèå
}
}
}
return (False);
}
//+------------------------------------------------------------------+
//| Ôóíêöèÿ, ïðîâåðÿþùàÿ, àêòèâèðîâàí ëè äàííûé îðäåð â îòêðûòóþ |
//| ïîçèöèþ |
//+------------------------------------------------------------------+
bool isOrderActive(int num) // èìÿ ôóíêöèè è ñïèñîê ïàðàìåòðîâ
{
int t, cnt1;
t = OrdersTotal();
for(cnt1 = 0; cnt1 < t; cnt1++)
{
OrderSelect(cnt1, SELECT_BY_POS, MODE_TRADES);
if(OrderSymbol() == Symbol())
{
if(OrderMagicNumber() == num)
{
if(OrderType() == OP_BUY || OrderType() == OP_SELL)
{
return(True);// âîçâðàùàåìîå çíà÷åíèå
}
}
}
}
return (False);
}
//+------------------------------------------------------------------+
//| Îïðåäåëåíèå ìàñèìàëüíîãî óðîâíÿ äëÿ äëèííûõ èëè êîðîòêèõ ïîçèöèé|
//+------------------------------------------------------------------+
int getTopLevel(int mode) // èìÿ ôóíêöèè è ñïèñîê ïàðàìåòðîâ
{
int t, cnt1, tLev, cLev;
t = OrdersTotal();
cLev = 0;
tLev = 0;
for(cnt1 = 0; cnt1 < t; cnt1++)
{
OrderSelect(cnt1, SELECT_BY_POS, MODE_TRADES);
if(OrderSymbol() == Symbol())
{
if(OrderType() == OP_BUY || OrderType() == OP_SELL)
{
//òîëüêî àêòèâèðîâàííûå ïîçèöèè
if(mode == 1)
{
//ïðîâåðêà óðîâíÿ äëÿ ëîíãîâ
if(OrderMagicNumber() == 881)
cLev = 12;
if(OrderMagicNumber() == 871)
cLev = 11;
if(OrderMagicNumber() == 861)
cLev = 10;
if(OrderMagicNumber() == 851)
cLev = 9;
if(OrderMagicNumber() == 841)
cLev = 8;
if(OrderMagicNumber() == 831)
cLev = 7;
if(OrderMagicNumber() == 821)
cLev = 6;
if(OrderMagicNumber() == 811)
cLev = 5;
if(OrderMagicNumber() == 801)
cLev = 4;
if(OrderMagicNumber() == 791)
cLev = 3;
if(OrderMagicNumber() == 781)
cLev = 2;
if(OrderMagicNumber() == 771)
cLev = 1;
}
else
{
//ïðîâåðêà óðîâíÿ äëÿ øîðòîâ
if(OrderMagicNumber() == 882)
cLev = 12;
if(OrderMagicNumber() == 872)
cLev = 11;
if(OrderMagicNumber() == 862)
cLev = 10;
if(OrderMagicNumber() == 852)
cLev = 9;
if(OrderMagicNumber() == 842)
cLev = 8;
if(OrderMagicNumber() == 832)
cLev = 7;
if(OrderMagicNumber() == 822)
cLev = 6;
if(OrderMagicNumber() == 812)
cLev = 5;
if(OrderMagicNumber() == 802)
cLev = 4;
if(OrderMagicNumber() == 792)
cLev = 3;
if(OrderMagicNumber() == 782)
cLev = 2;
if(OrderMagicNumber() == 772)
cLev = 1;
}
}
}
if(cLev > tLev)
tLev = cLev;
}
return(tLev);
}
//+------------------------------------------------------------------+
//| Îïðåäåëåíèå, ñêîëüêî ëîòîâ îòêðûâàòü ïî çàäàííîìó íîìåðó óðîâíÿ |
//+------------------------------------------------------------------+
double getLotByLevel(int level) // ôóíêöèÿ äëÿ âû÷èñëåíèÿ ëîòà ïî óðîâíþ
{
double lot1;
lot1 = startLots; // çíà÷åíèå ïî óìîë÷àíèþ
if(level == 1)
// ïåðâûå îðäåðà - òîëüêî äëÿ îòñ÷åòà óðîâíåé, ïîçèöèè ðàçìåðîì 0,1 ëîòà
lot1 = 0.1;
if(level == 2)
lot1 = NormalizeDouble(startLots*LotsLevel_2, 1);
if(level == 3)
lot1 = NormalizeDouble(startLots*LotsLevel_3, 1);
if(level == 4)
lot1 = NormalizeDouble(startLots*LotsLevel_4, 1);
if(level == 5)
lot1 = NormalizeDouble(startLots*LotsLevel_5, 1);
if(level == 6)
lot1 = NormalizeDouble(startLots*LotsLevel_6, 1);
if(level == 7)
lot1 = NormalizeDouble(startLots*LotsLevel_7, 1);
if(level == 8)
lot1 = NormalizeDouble(startLots*LotsLevel_8, 1);
if(level == 9)
lot1 = NormalizeDouble(startLots*LotsLevel_9, 1);
if(level == 10)
lot1 = NormalizeDouble(startLots*LotsLevel_10, 1);
if(level == 11)
lot1 = NormalizeDouble(startLots*LotsLevel_11, 1);
if(level == 12)
lot1 = NormalizeDouble(startLots*LotsLevel_12, 1);
return(lot1);
}
//+------------------------------------------------------------------+
//| Ôóíêöèÿ ïîëó÷åíèÿ öåíû îòêðûòèÿ îðäåðà ïî åãî ìàãè÷åñêîìó íîìåðó|
//+------------------------------------------------------------------+
double getOrderPriceByNum(int num)
{
int t, cnt1;
t = OrdersTotal();
for(cnt1 = 0; cnt1 < t; cnt1++)
{
OrderSelect(cnt1, SELECT_BY_POS, MODE_TRADES);
if(OrderSymbol() == Symbol())
{
if(OrderMagicNumber() == num)
{
return(OrderOpenPrice());
}
}
}
return (0);
}
//+------------------------------------------------------------------+
//| Ôóíêöèÿ ïîëó÷åíèÿ âðåìåíè îòêðûòèÿ îðäåðà ïî åãî ìàãè÷åñêîìó |
//| íîìåðó |
//+------------------------------------------------------------------+
datetime getOrderOpenTimeByNum (int num)
{
int t, cnt1;
t = OrdersTotal();
for(cnt1 = 0; cnt1 < t; cnt1++)
{
OrderSelect(cnt1, SELECT_BY_POS, MODE_TRADES);
if(OrderSymbol() == Symbol())
{
if(OrderMagicNumber() == num)
{
return(OrderOpenTime());
}
}
}
return (0);
}
//+------------------------------------------------------------------+
//| Ôóíêöèÿ ñ÷èòàåò îòêðûòûå ëîòû äëÿ ëîíãîâ ïî äàííîìó èíñòðóìåíòó |
//+------------------------------------------------------------------+
double getBuyLotsSum(int mode)
{
int t, cnt1;
double sm;
t = OrdersTotal();
sm = 0;
for(cnt1 = 0; cnt1 < t; cnt1++)
{
OrderSelect(cnt1, SELECT_BY_POS, MODE_TRADES);
if(mode != 1)
{
if(OrderType() == OP_BUY && OrderSymbol() == Symbol())
{
sm = sm + OrderLots();
}
}
else
{
// à çäåñü ïî âñåì îòêðûòûì ïîçèöèÿì ñ÷åòà
if(OrderType() == OP_BUY)
{
sm = sm + OrderLots();
}
}
}
return(sm);
}
//+------------------------------------------------------------------+
//| Ôóíêöèÿ ñ÷èòàåò îòêðûòûå ëîòû äëÿ øîðòîâ ïî äàííîìó èíñòðóìåíòó |
//+------------------------------------------------------------------+
double getSellLotsSum(int mode)
{
int t, cnt1;
double sm;
t = OrdersTotal();
sm = 0;
for(cnt1 = 0; cnt1 < t; cnt1++)
{
OrderSelect(cnt1, SELECT_BY_POS, MODE_TRADES);
if(mode != 1)
{
if(OrderType() == OP_SELL && OrderSymbol() == Symbol())
{
sm = sm + OrderLots();
}
}
else
{
// à çäåñü ïî âñåì îòêðûòûì ïîçèöèÿì ñ÷åòà
if(OrderType() == OP_SELL)
{
sm = sm + OrderLots();
}
}
}
return(sm);
}
//+------------------------------------------------------------------+
//| Ôóíêöèÿ äëÿ ìîäèôèêàöèè îòëîæåííûõ îðäåðîâ ëîíãîâ çäåñü |
//| îïðåäåëÿåì ìàêñèìàëüíûé ìàãè÷åñêèé íîìåð îòêðûòîãî îðäåðà äëÿ |
//| ëîíãîâ |
//+------------------------------------------------------------------+
int getMaxLongNum()
{
int t, cnt1;
int topL;
t = OrdersTotal();
topL = 0;
for(cnt1 = 0; cnt1 < t; cnt1++)
{
OrderSelect(cnt1, SELECT_BY_POS, MODE_TRADES);
if(OrderSymbol() == Symbol())
{
if(OrderType() == OP_BUY)
{
if(OrderMagicNumber() > topL)
topL = OrderMagicNumber();
}
}
}
return (topL);
}
//+------------------------------------------------------------------+
//| Ôóíêöèÿ îïðåäåëÿåò ìàêñèìàëüíûé ìàãè÷åñêèé íîìåð îòêðûòîãî |
//| îðäåðà äëÿ øîðòîâ |
//+------------------------------------------------------------------+
int getMaxShortNum()
{
int t, cnt1;
int topL;
t = OrdersTotal();
topL = 0;
for(cnt1 = 0; cnt1 < t; cnt1++)
{
OrderSelect(cnt1, SELECT_BY_POS, MODE_TRADES);
if(OrderSymbol() == Symbol())
{
if(OrderType() == OP_SELL)
{
if(OrderMagicNumber() > topL)
topL = OrderMagicNumber();
}
}
}
return (topL);
}
//+------------------------------------------------------------------+
//| Ôóíêöèÿ îïðåäåëÿåò ñëåäóþùèé ìàãè÷åñêèé íîìåð ïî äàííîìó |
//+------------------------------------------------------------------+
int getNextOrderNum(int n1)
{
if(n1 == 771)
return (781);
if(n1 == 781)
return (791);
if(n1 == 791)
return (801);
if(n1 == 801)
return (811);
if(n1 == 811)
return (821);
if(n1 == 821)
return (831);
if(n1 == 831)
return (841);
if(n1 == 841)
return (851);
if(n1 == 851)
return (861);
if(n1 == 861)
return (871);
if(n1 == 871)
return (881);
if(n1 == 772)
return (782);
if(n1 == 782)
return (792);
if(n1 == 792)
return (802);
if(n1 == 802)
return (812);
if(n1 == 812)
return (822);
if(n1 == 822)
return (832);
if(n1 == 832)
return (842);
if(n1 == 842)
return (852);
if(n1 == 852)
return (862);
if(n1 == 862)
return (872);
if(n1 == 872)
return (882);
return (0);
}
//+------------------------------------------------------------------+
//| Ôóíêöèÿ âû÷èñëåíèå ìàãè÷åñêîãî íîìåðà ïî íîìåðó óðîâíÿ |
//+------------------------------------------------------------------+
int getNum(int dir, int level)
{
if(dir == 1)
{
//äëÿ ëîíãîâ
if(level == 1)
return(771);
if(level == 2)
return(781);
if(level == 3)
return(791);
if(level == 4)
return(801);
if(level == 5)
return(811);
if(level == 6)
return(821);
if(level == 7)
return(831);
if(level == 8)
return(841);
if(level == 9)
return(851);
if(level == 10)
return(861);
if(level == 11)
return(871);
if(level == 12)
return(881);
}
else
{
if(level == 1)
return(772);
if(level == 2)
return(782);
if(level == 3)
return(792);
if(level == 4)
return(802);
if(level == 5)
return(812);
if(level == 6)
return(822);
if(level == 7)
return(832);
if(level == 8)
return(842);
if(level == 9)
return(852);
if(level == 10)
return(862);
if(level == 11)
return(872);
if(level == 12)
return(882);
}
}
//+------------------------------------------------------------------+
//| Ôóíêöèÿ ìîäèôèêàöèè îòëîæåííîãî îðäåðà |
//+------------------------------------------------------------------+
// çäåñü ïîëó÷àåì âû÷èñëåííûå öåíû îòêðûòèÿ è òýéêïðîôèòà äëÿ
// îòëîæåííûõ îðäåðîâ è åñëè îíè îòëè÷àþòñÿ îò öåí ìîäèôèöèðóåìîãî
// îðäåðà, èçìåíÿåì èõ.
int modOrder(int num, double oprice, double prprice)
{
int t, cnt1, err, start;
bool tic;
double p1, p2;
t = OrdersTotal();
for(cnt1 = 0; cnt1 < t; cnt1++)
{
OrderSelect(cnt1, SELECT_BY_POS, MODE_TRADES);
if(OrderSymbol() == Symbol() && OrderMagicNumber() == num)
{
if((OrderOpenPrice() != oprice || OrderTakeProfit() != prprice) &&
oprice != 0)
{
if(OrderType() == OP_BUYSTOP || OrderType() == OP_SELLLIMIT)
{
p1 = oprice;
p2 = prprice;
NormalizeDouble(p2, MarketInfo(Symbol(), MODE_DIGITS));
NormalizeDouble(p1, MarketInfo(Symbol(), MODE_DIGITS));
if(NormalizeDouble(OrderOpenPrice(), Digits) !=
NormalizeDouble(p1, Digits) ||
NormalizeDouble(OrderTakeProfit(), Digits) !=
NormalizeDouble(p2, Digits))
{
start = GetTickCount();
tic = OrderModify(OrderTicket(), p1, 0, p2, 0, Green);
if(ShowLog)
{
Print("ìîäèô BUYSTOP ", OrderOpenPrice(), "->", p1,
" t/p ", OrderTakeProfit(), "->", p2);
Print("Âðåìÿ ìîäèôèêàöèè ", (GetTickCount() - start) / 1000,
" ñåêóíä.");
}
if(tic)
PlaySound("alert.wav");
if(!tic)
{
err = GetLastError();
Print("Îøèáêà = ", err, " (", ErrorDescription(err), ")");
}
Sleep(timeOut);
}
}
if(OrderType() == OP_SELLSTOP || OrderType() == OP_BUYLIMIT)
{
p1 = oprice;
p2 = prprice;
NormalizeDouble(p2, MarketInfo(Symbol(), MODE_DIGITS));
NormalizeDouble(p1, MarketInfo(Symbol(), MODE_DIGITS));
if(NormalizeDouble(OrderOpenPrice(), Digits) !=
NormalizeDouble(p1, Digits) ||
NormalizeDouble(OrderTakeProfit(), Digits) !=
NormalizeDouble(p2, Digits))
{
start = GetTickCount();
tic = OrderModify(OrderTicket(), p1, 0, p2, 0, Green);
if(ShowLog)
{
Print("ìîäèô SELLSTOP ", OrderOpenPrice(), "->", p1,
" t/p ", OrderTakeProfit(),"->", p2);
Print("Âðåìÿ ìîäèôèêàöèè ", (GetTickCount() - start) / 1000,
" ñåêóíä.");
}
if(tic)
PlaySound("alert.wav");
if(!tic)
{
err = GetLastError();
Print("Îøèáêà = ", err, " (", ErrorDescription(err), ")");
}
Sleep(timeOut);
}
}
}
}
}
return (1);
}
//+------------------------------------------------------------------+
//| Ôóíêöèÿ ïîäñ÷åòà ïðîôèòà ïî ïîçèöèÿì â çàâèñèìîñòè îò ðåæèìà: ïðè|
//| mode=1 òîëüêî äëÿ òåêóùåãî èíñòðóìåíòà, ïðè ëþáîì äðóãîì äëÿ âñåõ|
//| ïîçèöèé ñ÷åòà |
//+------------------------------------------------------------------+
double getAllProfit(int mode)
{
int t, cnt1;
double pf;
t = OrdersTotal();
pf = 0;
for(cnt1 = 0; cnt1 < t; cnt1++)
{
OrderSelect(cnt1, SELECT_BY_POS, MODE_TRADES);
if(mode == 1)
{
if(OrderSymbol() == Symbol() && (OrderType() == OP_BUY ||
OrderType() == OP_SELL))
{
pf = pf + OrderProfit() + OrderSwap() + OrderCommission();
}
}
else
{
if(mode == 2 && OrderSymbol() == Symbol() && OrderType() == OP_BUY)
{
pf = pf + OrderProfit() + OrderSwap() + OrderCommission();
}
if(mode == 3 && OrderSymbol() == Symbol() && OrderType() == OP_SELL)
{
pf = pf + OrderProfit() + OrderSwap() + OrderCommission();
}
}
}
return (pf);
}
//+------------------------------------------------------------------+
//| Ïðè ëþáîì äðóãîì äëÿ âñåõ ïîçèöèé ñ÷åòà |
//+------------------------------------------------------------------+
double getDayProfit(int mode, int dayShift)
{
int t, cnt1, cyear, cmonth, cday;
double pf;
datetime ctm;
t = HistoryTotal();
pf = 0;
for(cnt1 = 0; cnt1 < t; cnt1++)
{
OrderSelect(cnt1, SELECT_BY_POS, MODE_HISTORY);
ctm = OrderCloseTime();
cyear = TimeYear(ctm);
cmonth = TimeMonth(ctm);
cday = TimeDay(ctm);
if(cyear == Year() && cmonth == Month() && cday == (Day() - dayShift))
{
if(mode == 1)
{
//ïðèáûëü ïî ëîíãàì è øîðòàì
if(OrderType() == OP_BUY || OrderType() == OP_SELL)
{
pf = pf + OrderProfit() + OrderSwap() + OrderCommission();
}
}
else
{
if(mode == 2 && OrderType() == OP_BUY)
{
//ïðèáûëü òîëüêî ïî ëîíãàì
pf = pf + OrderProfit() + OrderSwap() + OrderCommission();
}
if(mode == 3 && OrderType() == OP_SELL)
{
//ïðèáûëü òîëüêî ïî øîðòàì
pf = pf + OrderProfit() + OrderSwap() + OrderCommission();
}
}
}
}
return (pf);
}
//+------------------------------------------------------------------+
//| Ðàñ÷åò öåíû, ïî êîòîðîé âûñòàâëÿåòñÿ îðäåð SellStop |
//+------------------------------------------------------------------+
double setPriceSellStop()
{
double topPrice, PriceSetka, HighestPriceInRange;
int NumPoloski, NumBarsAfterOpenedOrder;
datetime OpenOrderTime;
if(mode_work == 0)
{
topPrice = getOrderPriceByNum(getMaxShortNum());
OpenOrderTime = getOrderOpenTimeByNum(getMaxShortNum());
}
if(mode_work ==1 )
{
topPrice = getOrderPriceByNum(getMaxLongNum());
OpenOrderTime = getOrderOpenTimeByNum(getMaxLongNum());
}
NumBarsAfterOpenedOrder = iBarShift(NULL, 0, OpenOrderTime, false);
HighestPriceInRange = Highest(NULL, 0, MODE_HIGH, NumBarsAfterOpenedOrder, 0);
// íîìåð ïîëîñêè ïîä òåêóùåé öåíîé BID
NumPoloski = MathAbs(MathFloor((Bid - topPrice) / (Step*Point)));
// çíà÷åíèå öåíû, ñîîòâåòñòâóþùåå ýòîé ïîëîñêå
PriceSetka = topPrice + NumPoloski*Step*Point;
if(HighestPriceInRange < PriceSetka + Step*Point &&
PriceSetka >= topPrice + Step*Point && Bid > topPrice)
{
return(NormalizeDouble(PriceSetka - Step*Point, Digits));
}
}
//+------------------------------------------------------------------+
//| Ðàñ÷åò öåíû, ïî êîòîðîé âûñòàâëÿåòñÿ îðäåð BuyStop |
//+------------------------------------------------------------------+
double setPriceBuyStop()
{
double lowPrice, PriceSetka, LowestPriceInRange;
int NumPoloski, NumBarsAfterOpenedOrder;
datetime OpenOrderTime;
if(mode_work == 0)
{
lowPrice = getOrderPriceByNum(getMaxLongNum());
OpenOrderTime = getOrderOpenTimeByNum(getMaxLongNum());
}
if(mode_work == 1)
{
lowPrice = getOrderPriceByNum(getMaxShortNum());
OpenOrderTime = getOrderOpenTimeByNum(getMaxShortNum());
}
NumBarsAfterOpenedOrder = iBarShift(NULL, 0, OpenOrderTime, false);
LowestPriceInRange = Lowest(NULL, 0, MODE_LOW, NumBarsAfterOpenedOrder, 0);
// íîìåð ïîëîñêè íàä òåêóùåé öåíîé ASK
NumPoloski = MathAbs(MathFloor((lowPrice - Ask) / (Step*Point)));
PriceSetka = lowPrice - NumPoloski*Step*Point;
// çíà÷åíèå öåíû, ñîîòâåòñòâóþùåå ýòîé ïîëîñêå
if(LowestPriceInRange > PriceSetka - Step*Point &&
PriceSetka <= lowPrice - Step*Point && Ask < lowPrice)
{
return(NormalizeDouble(PriceSetka + Step*Point,Digits));
}
}
//+------------------------------------------------------------------+
//| Ôóíêöèÿ çàêðûòèÿ îðäåðîâ ïî äîñòèæåíèþ ïðîôèòà |
//+------------------------------------------------------------------+
bool getProfitOrdersClose()
{
int cnt1, err, tic1,tic2, LotBy, LotBy1, i;
bool ticdone;
int T_sell[10], T_buy[10], a;
a = 0;
for(cnt1 = 0; cnt1 < OrdersTotal(); cnt1++)
{
//ïðîâåðÿåì, ìîæíî ëè çàêðûòü âñòðå÷íûå îðäåðà áåç ïîòåðè ñïðåäà
OrderSelect(cnt1, SELECT_BY_POS);
tic1 = OrderTicket();
LotBy = OrderLots();
if(OrderType() == OP_SELL)
{
for(i = 0; i < OrdersTotal(); i++)
{
OrderSelect(i, SELECT_BY_POS);
tic2 = OrderTicket();
LotBy1 = OrderLots();
if(OrderType() == OP_BUY && LotBy == LotBy1 &&
OrderSelect(tic1, SELECT_BY_TICKET) &&
OrderSelect(tic2, SELECT_BY_TICKET))
{
T_sell[a] = tic1;
T_buy[a] = tic2;
a++;
}
}
}
}
for(cnt1 = 0; cnt1 < a; cnt1++)
{
// çàêðûâàåì âñòðå÷íûå îðäåðà
if(OrderSelect(T_sell[cnt1], SELECT_BY_TICKET) &&
OrderSelect(T_buy[cnt1], SELECT_BY_TICKET))
{
ticdone = OrderCloseBy(T_sell[cnt1], T_buy[cnt1], Green);
if(!ticdone)
{
err = GetLastError();
Print("Îøèáêà çàêðûòèÿ âñòðå÷íîãî îðäåðà = ", ErrorDescription(err),
"¹ òèêåòà (sell)= ", T_sell[cnt1], "¹ òèêåòà (buy)= ", T_buy[cnt1]);
}
}
}
for(cnt1 = OrdersTotal(); cnt1 >= 0; cnt1--)
{
// çàêðûâàåì âñå îñòàâøèåñÿ îðäåðà
OrderSelect(cnt1, SELECT_BY_POS, MODE_TRADES);
if(OrderSymbol() == Symbol())
{
if(OrderType() == OP_BUY)
{
ticdone = OrderClose(OrderTicket(), OrderLots(), Ask, 5, Green);
if(ticdone)
PlaySound("timeout.wav");
if(!ticdone)
{
err = GetLastError();
if(err != 0)
Print("Îøèáêà çàêðûòèÿ îðäåðà = ", ErrorDescription(err));
}
}
if(OrderType() == OP_SELL)
{
ticdone = OrderClose(OrderTicket(), OrderLots(), Bid, 5, Green);
if(ticdone)
PlaySound("timeout.wav");
if(!ticdone)
{
err = GetLastError();
if(err != 0)
Print("Îøèáêà çàêðûòèÿ îðäåðà = ", ErrorDescription(err));
}
}
}
}
return (False);
}
//+------------------------------------------------------------------+
//| Âçâåøåííàÿ öåíà äëÿ âñåõ ïîçèöèé â îäíó ñòîðîíó äëÿ âû÷èñëåíèÿ |
//| çíà÷åíèÿ òåéêïðîôèòà âñåé ñåðèè |
//+------------------------------------------------------------------+
double getSumWeightedPrice(int mode)
{
int i;
double sumWeightedPrice;
for(i=0;i<=OrdersTotal();i++)
{
OrderSelect(i,SELECT_BY_POS);
if(OrderType() == OP_BUY && mode == 1)
{
sumWeightedPrice = sumWeightedPrice + OrderLots()*OrderOpenPrice();
}
if(OrderType() == OP_SELL && mode == 2)
{
sumWeightedPrice = sumWeightedPrice+OrderLots()*OrderOpenPrice();
}
}
return(sumWeightedPrice);
}
//+------------------------------------------------------------------+
//| Îïðåäåëåíèå öåíû çàêðûòèÿ âñåõ îðäåðîâ, íåîáõîäèìîé äëÿ |
//| âûñòàâëåíèÿ òåéêïðîôèòîâ è ñòîïëîññîâ äëÿ îðäåðîâ |
//+------------------------------------------------------------------+
double getOptimalTakeProfit(double multiplier, bool SELL_BUY)
{
//ñ ó÷åòîì îòêðûòîãî ïðîòèâîïîëîæíîãî ïëå÷à
double TempOptimalTP, TempOptimalTP_sell, TempOptimalTP_buy, NeedTP_points, lots;
int i;
double profit_money, price_tick;
profit_money = AccountBalance()*ProfitPercent*multiplier / 100;
price_tick = MarketInfo(Symbol(), MODE_TICKVALUE);
// íåîáõîäèìîå êîëè÷åñòâî ïóíêòîâ (ïðè ëîòå=1) äëÿ äîñòèæåíèÿ ïðîôèòà
NeedTP_points = profit_money*Point / price_tick;
lots = getBuyLotsSum(1) + getSellLotsSum(1);
if(getSellLotsSum(1) != 0)
{
TempOptimalTP_sell = (getSumWeightedPrice(2) - NeedTP_points) / getSellLotsSum(1);
}
else
{
// áåç ó÷åòà îòêðûòîãî ïðîòèâîïîëîæíîãî ïëå÷à
TempOptimalTP_sell = 0;
}
if(getBuyLotsSum(1) != 0)
{
TempOptimalTP_buy = (getSumWeightedPrice(1) + NeedTP_points) / getBuyLotsSum(1);
}
else
{
// áåç ó÷åòà îòêðûòîãî ïðîòèâîïîëîæíîãî ïëå÷à
TempOptimalTP_buy = 0;
}
if(!SELL_BUY)
{
if(getBuyLotsSum(1) == getSellLotsSum(1))
{
TempOptimalTP = TempOptimalTP_buy;
}
else
{
if(lots != 0)
{
TempOptimalTP = (TempOptimalTP_buy*getBuyLotsSum(1) +
TempOptimalTP_sell*getSellLotsSum(1) +
NeedTP_points) / lots;
}
else
{
TempOptimalTP = 0;
}
}
//ñ ó÷åòîì îòêðûòîãî ïðîòèâîïîëîæíîãî ïëå÷à
return(NormalizeDouble(TempOptimalTP_buy, Digits));
}
if(SELL_BUY)
{
if(getBuyLotsSum(1) == getSellLotsSum(1))
{
TempOptimalTP = TempOptimalTP_sell;
}
else
{
if(lots != 0)
{
TempOptimalTP = (TempOptimalTP_buy*getBuyLotsSum(1) +
TempOptimalTP_sell*getSellLotsSum(1) -
NeedTP_points) / lots;
}
else
{
TempOptimalTP = 0;
}
}
//ñ ó÷åòîì îòêðûòîãî ïðîòèâîïîëîæíîãî ïëå÷à
return(NormalizeDouble(TempOptimalTP_sell,Digits));
}
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
void setPendingOrders(int mode)
{
int i, start, err;
bool ticket;
double lot;
// ïðîáîéíûé ðåæèì
if(mode == 0)
{
//âûñòàâëÿåì îðäåðà äëÿ ëîíãîâ
if(getTopLevel(1) < maxLevel && !isMgNum(100))
{
for(i = 1; i < 12; i++)
{
if(getTopLevel(1) == i && isMgNum(getNum(1, i+1)) == False &&
isOrderActive(getNum(1, i)) == True && setPriceBuyStop() != 0 &&
getOrderPriceByNum(getMaxLongNum()) != setPriceBuyStop())
{
start = GetTickCount();
ticket = OrderSend(Symbol(), OP_BUYSTOP,
getLotByLevel(getTopLevel(1) + 1),
setPriceBuyStop(), 3, 0, 0,
StringConcatenate(i + 1, " ëîíã"),
getNum(1, i + 1), 0, Green);
if(ShowLog)
{
Print("Âðåìÿ îòêðûòèÿ îðäåðà ", (GetTickCount() - start) / 1000,
" ñåêóíä.");
}
if(ticket)
PlaySound("alert.wav");
if(!ticket)
{
err = GetLastError();
Print("Îøèáêà = ", err, " (", ErrorDescription(err), ")");
}
return(1);
}
}
}
//âûñòàâëÿåì îðäåðà äëÿ øîðòîâ
if(getTopLevel(2) < maxLevel && !isMgNum(101))
{
for(i = 1; i < 12; i++)
{
if(getTopLevel(2) == i && isMgNum(getNum(0, i + 1)) == False &&
isOrderActive(getNum(0, i)) == True && setPriceSellStop() != 0 &&
getOrderPriceByNum(getMaxShortNum()) != setPriceSellStop())
{
start = GetTickCount();
ticket = OrderSend(Symbol(), OP_SELLSTOP,
getLotByLevel(getTopLevel(2) + 1),
setPriceSellStop(), 3, 0, 0,
StringConcatenate(i + 1, " øîðò"),
getNum(0, i + 1), 0, Red);
if(ShowLog)
{
Print("Âðåìÿ îòêðûòèÿ îðäåðà ", (GetTickCount() - start) / 1000,
" ñåêóíä.");
}
if(ticket)
PlaySound("alert.wav");
if(!ticket)
{
err = GetLastError();
Print("Îøèáêà = ", err, " (", ErrorDescription(err), ")");
}
return(1);
}
}
}
}
// îòáîéíûé ðåæèì
if(mode == 1)
{
//âûñòàâëÿåì îðäåðà äëÿ ëîíãîâ
if(getTopLevel(1) < maxLevel)
{
for(i = 1; i < 12; i++)
{
if(getTopLevel(2) == i && isMgNum(getNum(0, i + 1)) == False &&
isOrderActive(getNum(0, i)) == True && setPriceBuyStop() != 0 &&
getOrderPriceByNum(getMaxShortNum())!= setPriceBuyStop())
{
//÷òîáû íå áûëî ëîêîâ - getTopLevel(1)
start = GetTickCount();
lot = getLotByLevel(getTopLevel(1) + 1);
if(lot > MarketInfo(Symbol(), MODE_MAXLOT))
{
lot = MarketInfo(Symbol(), MODE_MAXLOT);
}
ticket = OrderSend(Symbol(), OP_SELLLIMIT, lot, setPriceBuyStop(),
3, 0, 0, StringConcatenate(i + 1, " øîðò"),
getNum(0,i+1),0,Green);
if(ShowLog)
{
Print("Âðåìÿ îòêðûòèÿ îðäåðà ", (GetTickCount() - start) / 1000,
" ñåêóíä.");
}
if(ticket)
PlaySound("alert.wav");
if(!ticket)
{
err = GetLastError();
Print("Îøèáêà = ", err, " (", ErrorDescription(err), ")");
}
return(1);
}
}
}
//âûñòàâëÿåì îðäåðà äëÿ øîðòîâ
if(getTopLevel(2) < maxLevel)
{
for(i = 1; i < 12; i++)
{
if(getTopLevel(1) == i && isMgNum(getNum(1, i + 1)) == False &&
isOrderActive(getNum(1, i)) == True && setPriceSellStop() != 0 &&
getOrderPriceByNum(getMaxLongNum()) != setPriceSellStop())
{
start = GetTickCount();
// ÷òîáû íå áûëî ëîêîâ - getTopLevel(2)
lot = getLotByLevel(getTopLevel(2) + 1);
if(lot > MarketInfo(Symbol(), MODE_MAXLOT))
{
lot = MarketInfo(Symbol(), MODE_MAXLOT);
}
ticket = OrderSend(Symbol(), OP_BUYLIMIT, lot, setPriceSellStop(),
3, 0, 0, StringConcatenate(i + 1, " ëîíã"),
getNum(1, i + 1), 0, Red);
if(ShowLog)
{
Print("Âðåìÿ îòêðûòèÿ îðäåðà ", (GetTickCount() - start) / 1000,
" ñåêóíä.");
}
if(ticket)
PlaySound("alert.wav");
if(!ticket)
{
err = GetLastError();
Print("Îøèáêà = ", err, " (", ErrorDescription(err), ")");
}
return(1);
}
}
}
}
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
void setTrailingStop(int trailingSL, double multiplier)
{
int cnt1, t, s;
double PriceSL,spread, temp;
t = OrdersTotal();
s = MarketInfo(Symbol(), MODE_SPREAD);
spread = s*Point;
if((AccountEquity() - AccountBalance()) > AccountBalance()*ProfitPercent*multiplier / 100)
{
if(getBuyLotsSum(1) > getSellLotsSum(1))
{
PriceSL = Bid - Point*trailingSL;
if(mode_work == 0)
{
temp = Bid - getOrderPriceByNum(getMaxLongNum());
}
else
{
temp = Bid - getOrderPriceByNum(getMaxShortNum());
}
if(temp > Point*trailingSL)
{
if(OrderStopLoss() < PriceSL && mode_work == 0)
{
for(cnt1 = 0; cnt1 < t; cnt1++)
{
OrderSelect(cnt1, SELECT_BY_POS);
if(OrderType() == OP_BUY)
{
if(PriceSL > Bid)
{
OrderModify(OrderTicket(), OrderOpenPrice(),
OrderStopLoss(), PriceSL, 0, Green);
}
else
{
OrderModify(OrderTicket(), OrderOpenPrice(),
PriceSL, OrderTakeProfit(), 0, Green);
}
}
if(OrderType() == OP_SELL)
{
if(PriceSL > Bid)
{
OrderModify(OrderTicket(), OrderOpenPrice(),
PriceSL + spread, OrderTakeProfit(),
0, Green);
}
else
{
OrderModify(OrderTicket(), OrderOpenPrice(),
OrderStopLoss(), PriceSL + spread, 0, Green);
}
}
}
}
if(OrderStopLoss() > PriceSL && mode_work == 1 || OrderStopLoss() == 0)
{
for(cnt1 = 0; cnt1 < t; cnt1++)
{
OrderSelect(cnt1, SELECT_BY_POS);
if(OrderType() == OP_BUY)
{
if(PriceSL > Bid)
{
OrderModify(OrderTicket(), OrderOpenPrice(),
OrderStopLoss(), PriceSL, 0, Green);
}
else
{
OrderModify(OrderTicket(), OrderOpenPrice(), PriceSL,
OrderTakeProfit(), 0, Green);
}
}
if(OrderType() == OP_SELL)
{
if(PriceSL > Bid)
{
OrderModify(OrderTicket(), OrderOpenPrice(),
PriceSL + spread, OrderTakeProfit(), 0, Green);
}
else
{
OrderModify(OrderTicket(), OrderOpenPrice(),
OrderStopLoss(), PriceSL + spread, 0, Green);
}
}
}
}
}
}
if(getBuyLotsSum(1) < getSellLotsSum(1))
{
PriceSL = Ask + Point*trailingSL;
if(mode_work == 0)
{
temp = getOrderPriceByNum(getMaxShortNum()) - Ask;
}
else
{
temp = getOrderPriceByNum(getMaxLongNum()) - Ask;
}
if(temp > Point*trailingSL)
{
if(OrderStopLoss() > PriceSL || OrderStopLoss() == 0 && mode_work == 0)
{
for(cnt1 = 0; cnt1 < t; cnt1++)
{
OrderSelect(cnt1, SELECT_BY_POS);
if(OrderType() == OP_BUY)
{
if(PriceSL > Ask)
{
OrderModify(OrderTicket(), OrderOpenPrice(),
OrderStopLoss(), PriceSL-spread, 0, Green);
}
else
{
OrderModify(OrderTicket(), OrderOpenPrice(),
PriceSL - spread, OrderTakeProfit(), 0, Green);
}
}
if(OrderType() == OP_SELL)
{
if(PriceSL > Ask)
{
OrderModify(OrderTicket(), OrderOpenPrice(), PriceSL,
OrderTakeProfit(), 0, Green);
}
else
{
OrderModify(OrderTicket(), OrderOpenPrice(),
OrderStopLoss(), PriceSL, 0, Green);
}
}
}
}
if(OrderStopLoss() < PriceSL && mode_work == 1)
{
for(cnt1 = 0; cnt1 < t; cnt1++)
{
OrderSelect(cnt1, SELECT_BY_POS);
if(OrderType() == OP_BUY)
{
if(PriceSL > Ask)
{
OrderModify(OrderTicket(), OrderOpenPrice(),
OrderStopLoss(), PriceSL - spread, 0, Green);
}
else
{
OrderModify(OrderTicket(), OrderOpenPrice(),
PriceSL - spread, OrderTakeProfit(), 0, Green);
}
}
if(OrderType() == OP_SELL)
{
if(PriceSL > Ask)
{
OrderModify(OrderTicket(), OrderOpenPrice(), PriceSL,
OrderTakeProfit(), 0, Green);
}
else
{
OrderModify(OrderTicket(), OrderOpenPrice(),
OrderStopLoss(), PriceSL, 0, Green);
}
}
}
}
}
}
}
}
//+------------------------------------------------------------------+
//| Breakdowning martingail™ v 1.0.2 |
//+------------------------------------------------------------------+
int start()
{
double s, spread, Risk, level, LotsDifferent, lot_buy, lot_sell,
multiplier, forstep;
int total, err, i, start, cnt1;
string level_str, mode;
bool ticket;
s = MarketInfo(Symbol(), MODE_SPREAD);
spread = s*Point;
total = OrdersTotal();
LotsDifferent = MathAbs(getBuyLotsSum(1) - getSellLotsSum(1));
if(MinMaxStepMode == 0)
{
Step = Step;
}
if(MinMaxStepMode == 1)
{
Step = MathCeil((AccountBalance() - AccountEquity() + 1)*100000 / AccountBalance());
if(Step < 15)
{
Step = 15;
}
if(Step > 40)
{
Step = 40;
}
}
if(MinMaxStepMode == 2)
{
forstep = MathPow(AccountBalance() / AccountEquity(), 4);
Step = MathCeil(forstep*15);
}
if(AccountEquity() / AccountBalance() < 0.7)
{
mode_work = 1;
}
else
{
mode_work = 0;
}
// Âêëþ÷åíèå ìàíèìåíåäæìåíòà (âû÷èñëåíèå ëîòîâ)
if(MoneyManagement == true && LogariphmicMM == true)
{
Risk = MathCeil(Riskfactor*100 / MathSqrt(AccountBalance()));
if(Risk > 20)
Risk = 20;
startLots = MathCeil(AccountBalance()*Risk / 10000) / 10;
if(startLots > MarketInfo(Symbol(), MODE_MAXLOT))
{
startLots = MarketInfo(Symbol(), MODE_MAXLOT);
}
if(startLots < MarketInfo(Symbol(), MODE_MINLOT))
{
startLots = MarketInfo(Symbol(), MODE_MINLOT);
}
}
if(MoneyManagement == true && LogariphmicMM == false)
{
startLots = NormalizeDouble(AccountBalance()*Riskfactor / 100000, 1);
if(startLots > MarketInfo(Symbol(), MODE_MAXLOT))
{
startLots = MarketInfo(Symbol(), MODE_MAXLOT);
}
if(startLots < MarketInfo(Symbol(), MODE_MINLOT))
{
startLots = MarketInfo(Symbol(), MODE_MINLOT);
}
}
if(MoneyManagement == false && LogariphmicMM == false)
{
startLots =startLots;
}
//Îïðåäåëÿåì, áóäåì ëè èñïîëüçîâàòü OptimalTakePrifit
if(OptimalTakeProfit)
{
multiplier = MathSqrt(LotsDifferent);
}
if(!OptimalTakeProfit)
{
multiplier = 1;
}
//Îïðåäåëÿåì, áóäåì ëè èñïîëüçîâàòü NoTradeBeforeNewDay
if(getDayProfit(1, 0) > 0 && NoTradeBeforeNewDay)
{
TradeAllowed = false;
}
if(getDayProfit(1, 0) == 0 && NoTradeBeforeNewDay)
{
TradeAllowed = true;
}
//Ðàñïå÷àòêà ðàçëè÷íîé èíôîðìàöèè íà ýêðàíå
if(getBuyLotsSum(1) > getSellLotsSum(1))
{
level = getOptimalTakeProfit(multiplier, false) - spread;
}
if(getBuyLotsSum(1) < getSellLotsSum(1))
{
level = getOptimalTakeProfit(multiplier, true) + spread;
}
if(level != 0)
{
level_str = DoubleToStr(level, Digits);
}
else
{
//ðàñïå÷àòêà óðîâíÿ çàêðûòèÿ âñåõ îðäåðîâ
level_str=" ïîêà íåò, æäåì...";
}
if(mode_work == 0)
{
mode = "ïðîáîé (îðäåðà BuyStop è SellStop)";
}
if(mode_work == 1)
{
mode = "îòáîé (îðäåðà BuyLimit è SellLimit)";
}
ObjectSetText("label_object1", StringConcatenate("Ïëàíèðóåìûé óðîâåíü çàêðûòèÿ ñåðèè ïî ",
Symbol(), ": ", level_str), 9, "Lucida Console", NavajoWhite);
ObjectSetText("label_object2", StringConcatenate("Ðåæèì ðàáîòû : ", mode), 9,
"Lucida Console", NavajoWhite);
Comment("\n", "\n", "\n",
" Ïðîôèò ïî ëîíãàì = ", NormalizeDouble(getAllProfit(2), 2), " $", "\n",
" Ïðîôèò ïî øîðòàì = ", NormalizeDouble(getAllProfit(3), 2), " $", "\n",
" ---------------------------------------------------", "\n",
" Ïðîôèò ñåãîäíÿ = ", NormalizeDouble(getDayProfit(1, 0), 2), " $", "\n",
" Ïðîôèò â÷åðà = ", NormalizeDouble(getDayProfit(1, 1), 2), " $", "\n",
" Ïðîôèò ïîçàâ÷åðà = ", NormalizeDouble(getDayProfit(1, 2), 2), " $", "\n",
" ---------------------------------------------------", "\n",
" Balance = ",NormalizeDouble(AccountBalance(),2), " $", "\n",
" Equity = ",NormalizeDouble(AccountEquity(),2), " $", "\n",
" Free Margin = ", NormalizeDouble(AccountFreeMargin(),2), " $", "\n",
" ---------------------------------------------------", "\n",
" Sell Lots = ", getSellLotsSum(1), " | Buy Lots = ", getBuyLotsSum(1), "\n",
" ---------------------------------------------------", "\n",
" Êðåäèòíîå ïëå÷î ñ÷¸òà 1:", AccountLeverage());
// Åñëè òîðãîâëÿ íå ðàçðåøåíà, è íåò ïåðâè÷íûõ îðäåðîâ - âûõîä
if(isMgNum(getNum(1, 1)) == False && isMgNum(getNum(1, 1)) == False && !TradeAllowed)
{
return;
}
//âûñòàâëåíèå ïåðâûõ îðäåðîâ ñåðèè, åñëè òàêèõ åùå íåò
if(isMgNum(getNum(1, 1)) == False && TradeAllowed)
{
start = GetTickCount();
ticket = OrderSend(Symbol(), OP_BUY, getLotByLevel(1), NormalizeDouble(Ask, Digits),
3, 0, 0, "ïåðâàÿ ëîíã", getNum(1, 1), 0, Green);
if(ShowLog)
{
Print("Îòêðûòèå ïåðâîé ïîçèöèè ñåðèè ëîíãîâ ", Symbol(), " ask= ", Ask,
" ticket=", ticket);
Print("Âðåìÿ îòêðûòèÿ îðäåðà ", (GetTickCount() - start) / 1000, " ñåêóíä.");
}
if(ticket)
PlaySound("alert.wav");
if(!ticket)
{
err = GetLastError();
Print("Îøèáêà = ", err, " (", ErrorDescription(err), ")");
}
}
if(isMgNum(getNum(0, 1)) == False && TradeAllowed)
{
start = GetTickCount();
ticket = OrderSend(Symbol(), OP_SELL, getLotByLevel(1), NormalizeDouble(Bid, Digits),
3, 0, 0, "ïåðâàÿ øîðò", getNum(0, 1), 0, Green);
if(ShowLog)
{
Print("Îòêðûòèå ïåðâîé ïîçèöèè ñåðèè øîðòîâ ", Symbol(), " Bid= ", Bid,
" ticket=", ticket);
Print("Âðåìÿ îòêðûòèÿ îðäåðà ", (GetTickCount() - start) / 1000, " ñåêóíä.");
}
if(ticket)
PlaySound("alert.wav");
if(!ticket)
{
err = GetLastError();
Print("Îøèáêà = ", err, " (", ErrorDescription(err), ")");
}
}
//âûñòàâëÿåì îòëîæåííûé îðäåð, åñëè åñëè åñòü âîçìîæíîñòü
setPendingOrders(mode_work);
//ìîäèôèêàöèÿ îòëîæåííûõ îðäåðîâ BuyStop è SellStop (BuyLimit è SellLimit ïðè mode_work = 1)
if(mode_work == 0)
{
if(getOrderPriceByNum(getNextOrderNum(getMaxShortNum())) < setPriceSellStop() &&
setPriceSellStop() != 0)
{
//äëÿ øîðòîâ
modOrder(getNextOrderNum(getMaxShortNum()), setPriceSellStop(), 0);
}
if(getOrderPriceByNum(getNextOrderNum(getMaxLongNum())) > setPriceBuyStop() &&
setPriceBuyStop()!=0)
{
//äëÿ ëîíãîâ
modOrder(getNextOrderNum(getMaxLongNum()),setPriceBuyStop(),0);
}
}
if(mode_work == 1)
{
if(getOrderPriceByNum(getNextOrderNum(getMaxLongNum())) < setPriceSellStop() &&
setPriceSellStop() != 0)
{
modOrder(getNextOrderNum(getMaxLongNum()), setPriceSellStop(), 0);
}
if(getOrderPriceByNum(getNextOrderNum(getMaxShortNum())) > setPriceBuyStop() &&
setPriceBuyStop() != 0)
{
modOrder(getNextOrderNum(getMaxShortNum()), setPriceBuyStop(), 0);
}
}
// óñëîâèÿ äëÿ ôèêñàöèè ïðèáûëè
if(MathAbs(getBuyLotsSum(1) - getSellLotsSum(1)) < 0.2 &&
(isOrderActive(getNum(0, 2)) || isOrderActive(getNum(1, 2))))
{
// åñëè ñóììà ëîòîâ â ðàçíûå ñòîðîíû ïðèìåðíî îäèíàêîâà -
// çàêðûâàåì âñòðå÷íûìè îðäåðàìè (îáíóëÿåì íà÷àëüíûé óðîâåíü)
getProfitOrdersClose();
}
if(getAllProfit(1) > AccountBalance()*ProfitPercent*multiplier / 100 && TrailingStop == 0)
{
//ïðè äîñòèæåíèè íåîáõîäèìîãî ïðîôèòà çàêðûâàåì âñå îðäåðà
getProfitOrdersClose();
}
if(TrailingStop != 0)
{
// òðåéëèì ïðèáûëü, åñëè îíà åñòü
setTrailingStop(TrailingStop, multiplier);
}
// óäàëåíèå âñåõ ëèøíèõ îðäåðîâ â ñëó÷àå, åñëè ñåðèÿ çàêðûëàñü ïðîôèòîì,
// ò.å. åñëè íåò îòêðûòûõ îðäåðîâ ïåðâîé ñòóïåíè
// óäàëåíèå ëèøíèõ ëîíãîâ, åñëè íåò îðäåðà ïåðâîé ñòóïåíè
if(isOrderActive(getNum(1, 1)) == False)
{
for(i = getNum(1, 2); i < getNum(1, 9); i += 10)
{
//íà÷èíàåì ïåðåáèðàòü âñå ñî âòîðîãî óðîâíÿ
deleteOrderNum(i);
}
}
if(isOrderActive(getNum(0, 1)) == False)
{
//äëÿ øîðòîâ
for(i = getNum(0, 2); i < getNum(0, 9); i+=10)
{
deleteOrderNum(i);
}
}
return(0);
}
//+------------------------------------------------------------------+
Sample
Analysis
Market Information Used:
Indicator Curves created:
Indicators Used:
Custom Indicators Used:
Order Management characteristics:
Checks for the total of open orders
It can change open orders parameters, due to possible stepping strategy
It Closes Orders by itself
Other Features:
It plays sound alerts