//+------------------------------------------------------------------+

//| Anao.mq5 |
//| Fernando Sousa |
//| https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Fernando Sousa"
#property link "https://www.mql5.com"
#property version "2.00"
#include <Trade\Trade.mqh>

double VolComprVelaAtual; // Volume comprado na vela atual

double VolVendVelaAtual;
double VolComprVelaAnt=0.0;
double VolVendVelaAnt=0.0;
double volumeComprado;
double volumeVendido;
double VolumeTotal;
double num_lots = 5.0;
double acrescimo = 0.0;
double Gap_medio = 0.0;
double PMCompra;
double PMVenda;
double PMCAnterior;
double PMVAnterior;
double DeltaPreco;
double DeltaVenda;
double somaCPrecoxVolC = 0.0;
double somaVPrecoxVolV = 0.0;
double somaVolumeCompra;
double somaVolumeVenda;
double D1=0.0;
double D2=0.0;
double d3; // promeiro valor venda
double d4; // segundo valor venda
int Num_Vela_vendas;
int Num_Vela_compra;
int contaCompra = 0;
int contaVenda = 0;
int contaVela = 0;
int PosOrdem = 0;
ulong PositionTick;
// Volume vendido na vela atual
// Volume comprado na vela anterior
// Volume vendido na vela anterior
// Volume comprado
// Volume vendido
// Volume comprado menos o volume vendido
// Número de Lote padrão
// Lotes a mais
// Variação de pontos entre abertura e fechamento da vela
// Preço médio das compras.
// Preço médio das vendas.
// Preço médio das compras vela anterior
// Preço médio das vendas vela anterior
// Delta Preço vela atual (O+C+H+L)/4
// Delta venda vela anterior e atual
// Somatório do preço x volume comprado
// Somatório do preço x volume vendido
// Somatório do volume comprado
// Somatório do volume vendido
// primeiro valor compra
// segundo valor compra
// Total de vendas na vela
// Total de compras na vela
// Numero de operações de compra
// Numero de operações de venda
// Conta as velas em que o EA está ativo
// Define 1 para compra e -1 para venda
// Numero do tick

//---
CTrade trade;
MqlBookInfo book[];
MqlTick tick;
MqlRates candle[];
//+------------------------------------------------------------------+
//| Expert initialization function |
//+------------------------------------------------------------------+
int OnInit()
{
//---
MarketBookAdd(_Symbol);

//---
return(INIT_SUCCEEDED);
}
//+------------------------------------------------------------------+
//| Expert deinitialization function |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
//---
MarketBookRelease(_Symbol);
}
//+------------------------------------------------------------------+
//| Expert tick function |
//+------------------------------------------------------------------+
void OnTick()
{
MarketBookGet(_Symbol,book);
CopyRates(_Symbol,PERIOD_M1,0,5,candle);
ArraySetAsSeries(candle,true);
SymbolInfoTick(_Symbol, tick);
//---
if(tick.last==tick.ask) // Verifica se foi uma agressão de compra
{
Num_Vela_compra++;
volumeComprado += tick.volume_real;
}

if(tick.last==tick.bid) // Verifica se foi uma agressão de venda

{
Num_Vela_vendas++;
volumeVendido += tick.volume_real;
}
if(isNewBar()==true)
{
if(par(contaVela)==true)
{
D1 = TKprev((candle[1].open+candle[1].close+candle[1].high+candle[1].low)/4);
Print("Valor de D1 ",D1," Valor de D2 ",D2," Vela numero ",contaVela);
DeltaPreco = D1-D2;
Print("Delta ",DeltaPreco);
}
else
{
D2 = TKprev((candle[1].open+candle[1].close+candle[1].high+candle[1].low)/4);
Print("Valor de D1 ",D1," Valor de D2 ",D2," Vela numero ",contaVela);
DeltaPreco = D2-D1;
Print("Delta ",DeltaPreco);
}
VolComprVelaAtual = volumeComprado - VolComprVelaAnt;
VolVendVelaAtual = volumeVendido - VolVendVelaAnt;
VolComprVelaAnt = VolComprVelaAtual;
VolVendVelaAnt = VolVendVelaAtual;

contaVela++; // Conta as velas

if(contaVela>=1)
{
if(Posicionado()==true) // verifica se esta posicionado
{
if(PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_BUY)
{
if(PositionGetDouble(POSITION_PRICE_OPEN)<POSITION_PRICE_CURRENT)
{
trade.PositionClose(_Symbol,PositionTick);
}
}
if(PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_SELL)
{
if(PositionGetDouble(POSITION_PRICE_OPEN)>POSITION_PRICE_CURRENT)
{
trade.PositionClose(_Symbol,PositionTick);
}
}
}
else
{
if(VolComprVelaAtual>VolVendVelaAtual) //Condição de entrada na compra
{
if(DeltaPreco>0.0)
{
if(volumeComprado>volumeVendido)
{
CompraAMercado();
}

}
}
if(VolVendVelaAtual>VolComprVelaAtual) //Condição de entrada na venda
{
if(DeltaPreco<0.0)
{
if(volumeVendido>volumeComprado)
{
VendaAMercado();
}

}
}

}
 PMCAnterior = PMCompra;
PMVAnterior = PMVenda;
PMCompra = 0.0;
PMVenda = 0.0;
}

Num_Vela_compra = 0;
Num_Vela_vendas = 0;

}
}
//+------------------------------------------------------------------+
//+-----------------------------------------------------------------------------+
//| Retorna true se uma nova barra aparecer para um par de símbolos / períodos |
//+-----------------------------------------------------------------------------+
bool isNewBar()
{
//--- memorizar o tempo de abertura da última barra na variável estática
static datetime last_time=0;
//--- time atual
datetime
lastbar_time=(datetime)SeriesInfoInteger(Symbol(),Period(),SERIES_LASTBAR_DATE);

//--- se é a primeira chamada da função

if(last_time==0)
{
//--- ajusta o time e sai
last_time=lastbar_time;
return(false);
}

//--- se o time for diferente

if(last_time!=lastbar_time)
{
//--- memorizar o time e retornar verdadeiro
last_time=lastbar_time;
return(true);
}
//--- a barra não é nova; retorna falso
return(false);
}
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| Função que verifica se esta posicionado no Ativo |
//+------------------------------------------------------------------+
bool Posicionado()
//+--
{
if(PositionSelect(_Symbol)==true) //Verifica se existe uma posição abertaa no ativo
{
return(true);
}
 else
{
return(false);
}
}
//+------------------------------------------------------------------+
//| Função qde COMPRA A MERCADO |
//+------------------------------------------------------------------+

void CompraAMercado() // bser na documentação ordem das variaveis!!!

{
trade.Buy(num_lots+acrescimo,_Symbol,tick.ask,0.0,tick.ask+3.0,"Compra a mercado");

if(trade.ResultRetcode() == 10009)
{
contaCompra++;
//numeroDeOperacoesDia++;
Print("Ordem de Compra executada com sucesso! Compras já executadas =", contaCompra);
PositionTick = PositionGetTicket(POSITION_TICKET);
}
else
{
Print("Erro ao enviar Ordem Compra. Erro = ", GetLastError());
ResetLastError();
}
}
//+------------------------------------------------------------------+
//| Função qde VENDA A MERCADO |
//+------------------------------------------------------------------+

void VendaAMercado()
{
trade.Sell(num_lots+acrescimo,_Symbol,tick.bid,0.0,tick.bid-3.0,"Venda a mercado");

//---
if(trade.ResultRetcode() == 10009)
{
contaVenda++;
//numeroDeOperacoesDia++;
Print("Ordem de Venda executada com sucesso! Vendas já executadas = ",contaVenda);
PositionTick = PositionGetTicket(POSITION_TICKET);
}
else
{
Print("Erro ao enviar Ordem Venda. Erro = ", GetLastError());
ResetLastError();
}
}
//+------------------------------------------------------------------+
//| Função que normaliza o takeprofit e o stoploss |
//+------------------------------------------------------------------+
double TKprev(double entr)
 {
double cheio1 = (int)entr; //Parte inteira do takeprofit
double sobra = entr - cheio1; //Parte fracionária do takeprofit em uma variavel tipo
double
double sobra1 = NormalizeDouble(sobra, Digits()); //Em uma variavel tipo double coloca-se valor
normalizado pelo ativo
if(sobra1<=0.250) // compara se a sobra é menor ou igual a 25% sobra igual a
zero
{
sobra = 0.0;
}
else
{
sobra = 0.5; // Se maior que 25% e menor que 75% sobra igual 0.5
}
if(sobra1>0.750) // compara se a sobra é maior que 75% soma um inteiro
{
sobra = 1.0;
}
return cheio1 + sobra; //soma a parte inteira com a parte fracionária normalizada

}
bool par(double a)
{
double b;
double c;
if(a==0)
{
return true;
}
if(a==1)
{
return false;
}
b = a/2;
c = b - int(b);
if(c==0.0)
{
return true;
}
else
{
return false;
}
}