Просьба разобрать советник

Scalper_v7.ex4 (39 Kb)

Интерес работы данного советника привлекло данное видео:

www.youtube.com/watch?v=SAM0y5xo3ro

p.s.
Советник требует ввода пароля((

Вот еще такой же открытый:

//+------------------------------------------------------------------+
//| ScalperEA.mq4 |
//| Copyright 2016, (globfax@gmail.com) |
//| globfax@gmail.com |
//+------------------------------------------------------------------+
#property copyright «Copyright 2016, KaChing Scalper v6 (globfax@gmail.com)»
#property link «globfax@gmail.com»
#property version «6.00»
#property strict

extern string info1 = «All Average»;
extern int Signal_A = 1;
extern int Signal_B = 0;
extern int Signal_C = 1;
extern int CandleScan = 0;
extern bool SignalClose = true;
extern double BU = 100;
extern double BD = 50;
extern double SU = 50;
extern double SD = 100;
extern double StopLoss = 100;
extern double TakeProfit = 25;
extern double TrailingSL = 20;
extern int StartHourMA = 1;
extern int NoofHourMA = 22;
extern string Comments = «Scalper»;
extern string info3 = «General Parameter»;
extern int Magic = 71717;
extern double Lot = 0.01;
extern double LotPercentage = 2;
extern string UserID = «User ID»;
extern string ServerIP = «Server IP»;

int Account = 0;

double SL = 0;
double TP = 0;

int buyflag = 0;
int sellflag = 0;
int ticket = 0;
double tempLot = 0;

int tempHourMA = 0;
int MAHourcount = 0;

datetime prevTime = 0;
//+------------------------------------------------------------------+
//| Expert initialization function |
//+------------------------------------------------------------------+
int OnInit()
{
//---
if(Digits == 3 || Digits == 5) {
BU = BU * 10;
BD = BD * 10;
SU = SU * 10;
SD = SD * 10;
TakeProfit = TakeProfit * 10;
StopLoss = StopLoss * 10;
TrailingSL = TrailingSL * 10;
}
//---
return(INIT_SUCCEEDED);
}
//+------------------------------------------------------------------+
//| Expert deinitialization function |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
//---
}
//+------------------------------------------------------------------+
//| Expert tick function |
//+------------------------------------------------------------------+
void OnTick()
{
//---
if(Account != 0) {
if(Account != AccountNumber()) {
Alert(«Invalid Account number.»);
Sleep(20000);
return;
}
}
if(UserID != «1») {
Alert(«Invalid UserID»);
Sleep(20000);
return;
}
if(ServerIP != «1») {
Alert(«Invalid ServerIP»);
Sleep(20000);
return;
}
double MA0 = iMA(Symbol(),0,Signal_A,0,Signal_B,Signal_C,CandleScan);
double MA1 = iMA(Symbol(),0,Signal_A,0,Signal_B,Signal_C,CandleScan+1);
// TakeProfits();
if(TrailingSL != 0)
TrailingStops();
int sellcnt = 0;
for (int i=0; i<OrdersTotal(); i++) {
if (OrderSelect(i,SELECT_BY_POS,MODE_TRADES)==true) {
if(OrderSymbol() == Symbol() && OrderMagicNumber() == Magic && OrderType() == OP_SELL)
sellcnt++;
}
}
int buycnt = 0;
for (int i=0; i<OrdersTotal(); i++) {
if (OrderSelect(i,SELECT_BY_POS,MODE_TRADES)==true) {
if(OrderSymbol() == Symbol() && OrderMagicNumber() == Magic && OrderType() == OP_BUY)
buycnt++;
}
}
if(tempHourMA != Hour()) {
MAHourcount++;
tempHourMA = Hour();
}
string expire_date1 = «2017.12.01»;
datetime e_d1 = StrToTime(expire_date1);
if (CurTime() > e_d1 ) {
Sleep(22000);
return;
}
if(buycnt != 0 ) {
double buyHigh = FindHighBuyPrice();
double buyLow = FindLowBuyPrice();
if( ((Ask — buyHigh) >= BU*Point) || ((buyLow — Ask) >= BD*Point) ) {
ticket=OrderSend(Symbol(),OP_BUY,tempLot,Ask,MarketInfo(Symbol(),MODE_SPREAD),0,0,Comments,Magic,0,Blue);
if(ticket<0){
Print(«Error in buy: »,GetLastError());
return;
}else {
if(TakeProfit != 0) TP = Ask + TakeProfit*Point;
if(StopLoss != 0) SL = Ask — StopLoss*Point;
OrderModify(ticket,OrderOpenPrice(),SL,TP,0,Yellow);
buyflag = 0;
sellflag = 1;
prevTime = Time[0];
}
if((Ask — buyHigh) >= BU*Point) {
for (int i=0; i<OrdersTotal(); i++) {
if (OrderSelect(i,SELECT_BY_POS,MODE_TRADES)==true) {
if(OrderSymbol() == Symbol() && OrderMagicNumber() == Magic && OrderType() == OP_BUY) {
if(NormalizeDouble(OrderStopLoss(),Digits) != NormalizeDouble(SL,Digits) )
OrderModify(OrderTicket(),OrderOpenPrice(),NormalizeDouble(SL,Digits), OrderTakeProfit(),0, Yellow);
}
}
}
}
}
}
if(sellcnt != 0 ) {
double sellHigh = FindHighSellPrice();
double sellLow = FindLowSellPrice();
if( ((Bid — sellHigh) >= SU*Point) || ((sellLow — Bid) >= SD*Point) ) {
ticket = OrderSend(Symbol(),OP_SELL,tempLot,Bid,MarketInfo(Symbol(),MODE_SPREAD),0,0,Comments,Magic,0,Red);
if(ticket<0) {
Print(«Error in Sell: »,GetLastError());
return;
}else {
if(TakeProfit != 0) TP = Bid — TakeProfit*Point;
if(StopLoss != 0) SL = Bid + StopLoss*Point;
OrderModify(ticket,OrderOpenPrice(),SL,TP,0,Yellow);
sellflag = 0;
buyflag = 1;
prevTime = Time[0];
}
if((sellLow — Bid) >= SD*Point) {
for (int i=0; i<OrdersTotal(); i++) {
if (OrderSelect(i,SELECT_BY_POS,MODE_TRADES)==true) {
if(OrderSymbol() == Symbol() && OrderMagicNumber() == Magic && OrderType() == OP_SELL) {
if(NormalizeDouble(OrderStopLoss(),Digits) != NormalizeDouble(SL,Digits) )
OrderModify(OrderTicket(),OrderOpenPrice(),NormalizeDouble(SL,Digits), OrderTakeProfit(),0, Yellow);
}
}
}
}
}
}
// if(prevTime == Time[0])
// return;
if( Signal_A == 1 && (Hour() >= StartHourMA || MAHourcount < NoofHourMA) ) {
if(Hour() == StartHourMA) {
tempHourMA = Hour();
MAHourcount = 0;
}
if(MA0 > MA1 && buycnt == 0) {
if(SignalClose) {
int j = OrdersTotal();
while(j > 0) {
CLOSEORDER(«SELL»);
CLOSEORDER(«SELL»);
CLOSEORDER(«SELL»);
CLOSEORDER(«SELL»);
CLOSEORDER(«SELL»);
CLOSEORDER(«SELL»);
j--;
}
}
if(Lot == 0)
tempLot = NormalizeDouble(AccountBalance() * LotPercentage * 0.01 * 0.01,1);
else
tempLot = Lot;
if(tempLot > MarketInfo(Symbol(),MODE_MAXLOT) ) tempLot = NormalizeDouble(MarketInfo(Symbol(),MODE_MAXLOT),1);
if(tempLot < MarketInfo(Symbol(),MODE_MINLOT) ) tempLot = NormalizeDouble(MarketInfo(Symbol(),MODE_MINLOT),1);
ticket=OrderSend(Symbol(),OP_BUY,tempLot,Ask,MarketInfo(Symbol(),MODE_SPREAD),0,0,Comments,Magic,0,Blue);
if(ticket<0){
Print(«Error in buy: »,GetLastError());
return;
}else {
if(TakeProfit != 0) TP = Ask + TakeProfit*Point;
if(StopLoss != 0) SL = Ask — StopLoss*Point;
OrderModify(ticket,OrderOpenPrice(),SL,TP,0,Yellow);
prevTime = Time[0];
}
}
if(MA0 < MA1 && sellcnt == 0) {
if(SignalClose) {
int j = OrdersTotal();
while(j > 0) {
CLOSEORDER(«Buy»);
CLOSEORDER(«Buy»);
CLOSEORDER(«Buy»);
CLOSEORDER(«Buy»);
CLOSEORDER(«Buy»);
CLOSEORDER(«Buy»);
j--;
}
}
if(Lot == 0)
tempLot = NormalizeDouble(AccountBalance() * LotPercentage * 0.01 * 0.01,1);
else
tempLot = Lot;
if(tempLot > MarketInfo(Symbol(),MODE_MAXLOT) ) tempLot = NormalizeDouble(MarketInfo(Symbol(),MODE_MAXLOT),1);
if(tempLot < MarketInfo(Symbol(),MODE_MINLOT) ) tempLot = NormalizeDouble(MarketInfo(Symbol(),MODE_MINLOT),1);
ticket = OrderSend(Symbol(),OP_SELL,tempLot,Bid,MarketInfo(Symbol(),MODE_SPREAD),0,0,Comments,Magic,0,Red);
if(ticket<0) {
Print(«Error in Sell: »,GetLastError());
return;
}else {
if(TakeProfit != 0) TP = Bid — TakeProfit*Point;
if(StopLoss != 0) SL = Bid + StopLoss*Point;
OrderModify(ticket,OrderOpenPrice(),SL,TP,0,Yellow);
prevTime = Time[0];
}
}
}else {
if(Close[CandleScan] > MA0 && buycnt == 0 && (Hour() >= StartHourMA || MAHourcount < NoofHourMA) ) { //&& Close[2] < MA1
if(Hour() == StartHourMA) {
tempHourMA = Hour();
MAHourcount = 0;
}
if(SignalClose) {
int j = OrdersTotal();
while(j > 0) {
CLOSEORDER(«Sell»);
CLOSEORDER(«Sell»);
CLOSEORDER(«Sell»);
CLOSEORDER(«Sell»);
CLOSEORDER(«Sell»);
CLOSEORDER(«Sell»);
j--;
}
}
if(Lot == 0)
tempLot = NormalizeDouble(AccountBalance() * LotPercentage * 0.01 * 0.01,1);
else
tempLot = Lot;
if(tempLot > MarketInfo(Symbol(),MODE_MAXLOT) ) tempLot = NormalizeDouble(MarketInfo(Symbol(),MODE_MAXLOT),1);
if(tempLot < MarketInfo(Symbol(),MODE_MINLOT) ) tempLot = NormalizeDouble(MarketInfo(Symbol(),MODE_MINLOT),1);
ticket=OrderSend(Symbol(),OP_BUY,tempLot,Ask,MarketInfo(Symbol(),MODE_SPREAD),0,0,Comments,Magic,0,Blue);
if(ticket<0){
Print(«Error in buy: »,GetLastError());
return;
}else {
if(TakeProfit != 0) TP = Ask + TakeProfit*Point;
if(StopLoss != 0) SL = Ask — StopLoss*Point;
OrderModify(ticket,OrderOpenPrice(),SL,TP,0,Yellow);
buyflag = 1;
sellflag = 0;
prevTime = Time[0];
}
}
if(Close[CandleScan] < MA0 && sellcnt == 0 && (Hour() >= StartHourMA || MAHourcount < NoofHourMA) ) { //&& Close[2] > MA2
if(Hour() == StartHourMA) {
tempHourMA = Hour();
MAHourcount = 0;
}
if(SignalClose) {
int j = OrdersTotal();
while(j > 0) {
CLOSEORDER(«Buy»);
CLOSEORDER(«Buy»);
CLOSEORDER(«Buy»);
CLOSEORDER(«Buy»);
CLOSEORDER(«Buy»);
CLOSEORDER(«Buy»);
j--;
}
}
if(Lot == 0)
tempLot = NormalizeDouble(AccountBalance() * LotPercentage * 0.01 * 0.01,1);
else
tempLot = Lot;
if(tempLot > MarketInfo(Symbol(),MODE_MAXLOT) ) tempLot = NormalizeDouble(MarketInfo(Symbol(),MODE_MAXLOT),1);
if(tempLot < MarketInfo(Symbol(),MODE_MINLOT) ) tempLot = NormalizeDouble(MarketInfo(Symbol(),MODE_MINLOT),1);
ticket = OrderSend(Symbol(),OP_SELL,tempLot,Bid,MarketInfo(Symbol(),MODE_SPREAD),0,0,Comments,Magic,0,Red);
if(ticket<0) {
Print(«Error in Sell: »,GetLastError());
return;
}else {
if(TakeProfit != 0) TP = Bid — TakeProfit*Point;
if(StopLoss != 0) SL = Bid + StopLoss*Point;
OrderModify(ticket,OrderOpenPrice(),SL,TP,0,Yellow);
sellflag = 1;
buyflag = 0;
prevTime = Time[0];
}
}
}
}
//+------------------------------------------------------------------+
void CLOSEORDER(string ord)
{
for (int i=0; i<OrdersTotal(); i++)
{
if (OrderSelect(i,SELECT_BY_POS,MODE_TRADES)==true)
{
if (OrderSymbol()!=Symbol()||Magic!=OrderMagicNumber()) continue;
if (OrderType()==OP_BUY && ord==«Buy» && Magic == OrderMagicNumber() && OrderSymbol() == Symbol() )
OrderClose(OrderTicket(),OrderLots(),Bid,MarketInfo(Symbol(),MODE_SPREAD),Blue);
if (OrderType()==OP_SELL && ord==«Sell» && Magic == OrderMagicNumber() && OrderSymbol() == Symbol() )
OrderClose(OrderTicket(),OrderLots(),Ask,MarketInfo(Symbol(),MODE_SPREAD),Red);
}
}
}
//--------------------------------------------------------------------+
double FindHighBuyPrice() {

double orderprice = 0;;
double oldPrice=0, cPrice;
for(int i=OrdersTotal();i>=0;i--){
if (OrderSelect(i,SELECT_BY_POS,MODE_TRADES)==true) {
if(OrderSymbol()==Symbol() && OrderMagicNumber()==Magic && OrderType()==OP_BUY) {
cPrice=OrderOpenPrice();
if(cPrice>oldPrice) {
orderprice=OrderOpenPrice();
oldPrice=cPrice;
}
}
}
}
return(orderprice);
}
//+------------------------------------------------------------------+
double FindLowBuyPrice() {

double orderprice;
double oldPrice=10000, cPrice;
for(int i=OrdersTotal();i>=0;i--){
if (OrderSelect(i,SELECT_BY_POS,MODE_TRADES)==true) {
if(OrderSymbol()==Symbol() && OrderMagicNumber()==Magic && OrderType()==OP_BUY) {
cPrice=OrderOpenPrice();
if(cPrice<oldPrice) {
orderprice=OrderOpenPrice();
oldPrice=cPrice;
}
}
}
}
return(orderprice);
}
//+------------------------------------------------------------------+
double FindHighSellPrice() {

double orderprice = 0;
double oldPrice=0, cPrice;
for(int i=OrdersTotal();i>=0;i--){
if (OrderSelect(i,SELECT_BY_POS,MODE_TRADES)==true) {
if(OrderSymbol()==Symbol() && OrderMagicNumber()==Magic && OrderType()==OP_SELL) {
cPrice=OrderOpenPrice();
if(cPrice>oldPrice) {
orderprice=OrderOpenPrice();
oldPrice=cPrice;
}
}
}
}
return(orderprice);
}
//+------------------------------------------------------------------+
double FindLowSellPrice() {

double orderprice = 0;
double oldPrice=10000, cPrice;
for(int i=OrdersTotal();i>=0;i--){
if (OrderSelect(i,SELECT_BY_POS,MODE_TRADES)==true) {
if(OrderSymbol()==Symbol() && OrderMagicNumber()==Magic && OrderType()==OP_SELL) {
cPrice=OrderOpenPrice();
if(cPrice<oldPrice) {
orderprice=OrderOpenPrice();
oldPrice=cPrice;
}
}
}
}
return(orderprice);
}
//+------------------------------------------------------------------+
void TakeProfits() {

for (int i=0; i<OrdersTotal(); i++) {
if (OrderSelect(i,SELECT_BY_POS,MODE_TRADES)==true) {
if(OrderSymbol() == Symbol() && OrderMagicNumber() == Magic && OrderType() == OP_BUY) {
if( (Bid-OrderOpenPrice()) >= TakeProfit*Point )
OrderClose(OrderTicket(),OrderLots(),Bid,MarketInfo(Symbol(),MODE_SPREAD),White);
}
if(OrderSymbol() == Symbol() && OrderMagicNumber() == Magic && OrderType() == OP_SELL) {
if( (OrderOpenPrice()-Ask) >= TakeProfit*Point )
OrderClose(OrderTicket(),OrderLots(),Ask,MarketInfo(Symbol(),MODE_SPREAD),White);
}
}
}

}
//+------------------------------------------------------------------+
void TrailingStops() {
double profit2 = 0;
for (int j=0; j<OrdersTotal(); j++) {
for (int i=0; i<OrdersTotal(); i++) {
if (OrderSelect(i,SELECT_BY_POS,MODE_TRADES)==true) {
double StLo,OSL;
if(OrderSymbol() == Symbol() && Magic == OrderMagicNumber() && OrderType() == OP_BUY) {

profit2 = (MarketInfo(OrderSymbol(),MODE_BID) — OrderOpenPrice())/Point;
if( profit2 >= TrailingSL) {
OSL = OrderStopLoss();
StLo = SlLastBar(1,Bid,1,TrailingSL);
if (StLo > OSL) {
OrderModify(OrderTicket(),OrderOpenPrice(),NormalizeDouble(StLo,Digits),OrderTakeProfit(),0,Yellow);
}
}
}
if(OrderSymbol() == Symbol() && Magic == OrderMagicNumber() && OrderType() == OP_SELL) {
profit2 = ( OrderOpenPrice() — MarketInfo(OrderSymbol(),MODE_ASK))/Point;
if( profit2 >= TrailingSL) {
OSL = OrderStopLoss();
StLo = SlLastBar(-1,Ask,1,TrailingSL);
if (StLo < OSL || OSL==0 ) {
OrderModify(OrderTicket(),OrderOpenPrice(),NormalizeDouble(StLo,Digits),OrderTakeProfit(),0,Yellow);
}
}
}
}
}
}
}
//+------------------------------------------------------------------+
double SlLastBar(int tip,double price, int tipFr, int tral)
{
double fr;
if (tral!=0)
{
if (tip==1) fr = Bid — tral*Point;
else fr = Ask + tral*Point;
}
return(fr);
}
//+------------------------------------------------------------------+