Fausto Lok Trade / Profilo

//+------------------------------------------------------------------+
//| EA_ LoqBot.mq5 |
//| Conversão fiel do robô mais safado da história do Forex |
//+------------------------------------------------------------------+
#property copyright "©2025.1 EA LoqBot - O robô que enfia ordens sem dó kk"
#property link "http://t.me/Lokman_Trader"
#property version "2025.1"
#property description "@Lok_Trade - Desejo bons lucros (e umas entradas bem dadas)"
#property description "Tá Duro? Use Conta Cents Uns 20 MIL CENTS ou sua conta vai gritar mais que sua ex."
#property description "Recomendado para XAUUSD, GOLD, GBPUSD - Mas ele enfia em qualquer par, se você deixar..."
#property description "Alterações? Só no WhatsApp do mestre Lok: +55 71 99918-7219"
#property description "Este EA é mais esperto que corretora malandra. Proteção contra manipulação ATIVADA!"
#property description "Se sua conta quebrar, a culpa é sua, não do LoqBot. Aqui não tem garantia nem de sobriedade."
#property description "Minhas criações não implicam responsabilidade civil, moral ou espiritual pelo seu trade!"

#property script_show_inputs
#property strict
#resource "\\Images\\Loq_Bot.bmp"

//------------------------ CONTROLE DE VALIDADE ------------------------//
string ValidadeEA = "2029.12.20 23:59"; // Data de validade do robô
int RenewalNotificationDays = 30; // Dias antes do vencimento para avisar


//------------------------ ENTRADAS DO ROBÔ (EA LoqBot) ------------------------//

input int DetectarPontos = 5; // Subiu ou caiu isso? Mete ordem!
input double Lote = 0.01; // Lote padrão (se não quiser usar os separados)
input bool AtivarCompraInicial = true; // Começa comprando igual ex carente?
input bool AtivarVendaInicial = true; // Já chega vendendo igual hater?

//---------------------- LOTES CONFIGURÁVEIS -----------------------//
input double LoteBuyInicial = 0.01; // Lote da comprinha com carinho
input double LoteSellInicial = 0.01; // Lote da vendinha sem dó
double loteBuyAtual; // Armazena o lote de BUY em tempo real
double loteSellAtual; // Armazena o lote de SELL em tempo real

string inputBuyObj = "InputLoteBuy"; // Nome do input de lote BUY
string inputSellObj = "InputLoteSell"; // Nome do input de lote SELL
string btnAplicarLote = "BtnAplicarLotes"; // Botão que atualiza os lotes no painel

input double LucroParaFechar = 50.0; // Bateu isso de lucro? Fecha tudo e vai rir no grupo!
input int DistanciaMinimaPontos = 500; // Espaço mínimo entre entradas (sem empilhar igual desesperado)
input int LimiteMaximoCompras = 20; // Teto de compras antes de travar o cartão
input int LimiteMaximoVendas = 20; // Teto de vendas antes de surtar
input int MaxOrdensAntesInverter = 10; // Quantas entradas até mudar de lado?
input int TempoInverterSegundos = 10; // Espera quanto pra inverter o humor?
input int Slippage = 3; // Slippage máximo aceitável — sem escorregar demais
input int SpreadMaximo = 100; // Spread acima disso? Nem entra, tá caro!

//====================== ROBO 2 - CloseAllOnProfit ============================//
input bool AtivarRobo2 = true; // Ativa o Robô 2? (Fecha tudo no lucro da conta)
input double ProfitThreshold_R2 = 40.0; // Lucro flutuante da conta pra fechar tudo
input int Slippage_R2 = 3; // Slippage permitido no fechamento global
input int BlockTimeMinutes_R2 = 1; // Pausa depois de fechar geral (pra respirar)

input bool EnableFechaTudoButton = true; // Mostra botão “Fecha Tudo” Do ATIVO! no gráfico?
string FechaTudoBtnName = "FechaTudo"; // Nome do botão que resolve tudo

//====================== INDICADORES / PRESETS EXTERNOS ======================//
input bool EnableExternalIndicator = false; // Ativa sinal externo (pra quem acredita)
input string ExternalIndicatorName = "MeuIndicador.ex5"; // Nome do Indicador (.ex5) Salvo no MQL
input bool EnablePresetReader = false; // Lê config de arquivo externo?
input string ExternalPresetFile = "Presets.txt"; // Nome Arquivo de presets com a macumba


//------------------------ VARIÁVEIS INTERNAS ------------------------//
#include
CTrade trade;

double precoAnterior = 0;
datetime tempoUltimaTroca = 0;
int contadorCompras = 0;
int contadorVendas = 0;
int ordensDesdeUltimaTroca = 0;
datetime ultimoErroEnvio = 0;
int delayErroEnvioSegundos = 10;

bool AtivarCompra;
bool AtivarVenda;

//====================== VARIÁVEIS INTERNAS ROBO 2 ============================
bool ordersClosed_R2 = false;
datetime blockUntil_R2 = 0;

//+------------------------------------------------------------------+
//| Função de inicialização |
//+------------------------------------------------------------------+
int OnInit()
{
Print("=== EA LoqBot Online! Prepare-se: Ele vai te estopar com estilo ===");


// Verificação de validade do EA
datetime dataValidade = StringToTime(ValidadeEA);
datetime agora = TimeCurrent();

if(agora >= dataValidade)
{
MessageBox("O EA LoqBot Atualizou!\n\nValidade: " + ValidadeEA + "\nConsulte o desenvolvedor para Atualização.\nWhatsApp: +55 719 9918-7219", "EA EM Manuteção", MB_ICONERROR);
ExpertRemove(); // Remove do gráfico
return INIT_FAILED;
}

if((dataValidade - agora) <= (RenewalNotificationDays * 86400))
{
Print("️ ATENÇÃO: O EA LoqBotY irá expirar em breve! Validade: ", TimeToString(dataValidade, TIME_DATE | TIME_MINUTES));
MessageBox("️ O EA LoqBotY está perto do vencimento!\nValidade: " + ValidadeEA + "\nConsulte o desenvolvedor para renovação.", "AVISO DE VALIDADE", MB_ICONWARNING);
}

precoAnterior = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
tempoUltimaTroca = TimeCurrent();
loteBuyAtual = LoteBuyInicial;
loteSellAtual = LoteSellInicial;

InitializeExternalSupport();
ReadExternalPreset();
ShowLogo();
CreateFechaTudoButton();
CriarPainelLote();

Print("=== EA LoqBot chegou no gráfico! Se prepare pra ser penetrado pelo mercado ===");
return INIT_SUCCEEDED;
}



// Cores para piscar o label de lucro
color blinkColorsLucro[] = { clrLime, clrWhite };
color blinkColorsPrejuizo[] = { clrRed, clrWhite };
int fpBlinkColorIndex = 0;


//+------------------------------------------------------------------+
//| Função principal OnTick |
//+------------------------------------------------------------------+
void OnTick()
{
double ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
double bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);
double point = SymbolInfoDouble(_Symbol, SYMBOL_POINT);
double diferenca = (ask - precoAnterior) / point;

atualizarContadores();
atualizarLabelModo();
atualizarPainelContador();
BlinkFloatingProfit();
ChartRedraw();


// Botão "Aplicar" clicado para atualizar lotes
if(ObjectGetInteger(0, btnAplicarLote, OBJPROP_STATE) == true)
{
ObjectSetInteger(0, btnAplicarLote, OBJPROP_STATE, false); // resetar botão

string strBuy = ObjectGetString(0, inputBuyObj, OBJPROP_TEXT);
string strSell = ObjectGetString(0, inputSellObj, OBJPROP_TEXT);

double novoLoteBuy = StringToDouble(strBuy);
double novoLoteSell = StringToDouble(strSell);

if(novoLoteBuy > 0.0)
{
loteBuyAtual = novoLoteBuy;

}

if(novoLoteSell > 0.0)
{
loteSellAtual = novoLoteSell;

}

Print("️ Lotes atualizados → BUY: ", DoubleToString(loteBuyAtual, 2), " | SELL: ", DoubleToString(loteSellAtual, 2));
}




// Subiu? Compra!
if(diferenca >= DetectarPontos)
{
if(!spreadAceitavel()) return;

if(AtivarCompra && podeAbrirOrdem(ask, ORDER_TYPE_BUY) && contadorCompras < LimiteMaximoCompras)
{
abrirCompra(ask);
ordensDesdeUltimaTroca++;
precoAnterior = ask;
Print("[COMPRA] Subiu? Toma-lhe compra, sem vaselina!");
}
}

// Caiu? Venda!
if(diferenca <= -DetectarPontos)
{
if(AtivarVenda && podeAbrirOrdem(bid, ORDER_TYPE_SELL) && contadorVendas < LimiteMaximoVendas)
{
abrirVenda(bid);
ordensDesdeUltimaTroca++;
precoAnterior = ask;
Print("[VENDA] Desceu? É na tora! Vende essa bagaça!");
}
}

// Lucro flutuante
double lucroAtual = calcularLucroFlutuante();

if(lucroAtual >= LucroParaFechar)
{
Print(">>> Lucro atingido! Fecha tudo, vai tomar um litrão e relaxar");
fecharTodasOrdens();
contadorCompras = 0;
contadorVendas = 0;
ordensDesdeUltimaTroca = 0;
tempoUltimaTroca = TimeCurrent();
precoAnterior = SymbolInfoDouble(_Symbol, SYMBOL_ASK); // reinicia preço de base
}


// Trocar de lado
if(ordensDesdeUltimaTroca >= MaxOrdensAntesInverter || (TimeCurrent() - tempoUltimaTroca) >= TempoInverterSegundos)
{
Print("~ Mercado deu fora? Troca de lado igual ex enjoada. Agora vai de outro jeito ~");
inverterLogica();
}

if(AccountInfoDouble(ACCOUNT_MARGIN_FREE) < 100)
Print("## QUEBROU A CONTA? ENTÃO ASSUME, É VIADO MESMO KKK ##");


//=== EXECUTA ROBO 2 - FECHAMENTO GLOBAL POR LUCRO DE CONTA
ExecutarRobo2();
}


//+------------------------------------------------------------------+
//| Atualiza contadores de posições |
//+------------------------------------------------------------------+
void atualizarContadores()
{
contadorCompras = 0;
contadorVendas = 0;

for(int i = PositionsTotal() - 1; i >= 0; i--)
{
if(PositionGetTicket(i) > 0)
{
if(PositionGetString(POSITION_SYMBOL) == _Symbol)
{
if(PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY) contadorCompras++;
if(PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_SELL) contadorVendas++;
}
}
}
}

//+------------------------------------------------------------------+
//| Verifica se pode abrir nova ordem |
//+------------------------------------------------------------------+
bool podeAbrirOrdem(double precoAtual, ENUM_ORDER_TYPE tipo)
{
for(int i = PositionsTotal() - 1; i >= 0; i--)
{
if(PositionGetTicket(i) > 0)
{
if(PositionGetString(POSITION_SYMBOL) == _Symbol)
{
double precoOrdem = PositionGetDouble(POSITION_PRICE_OPEN);
double distancia = MathAbs(precoAtual - precoOrdem) / SymbolInfoDouble(_Symbol, SYMBOL_POINT);
if(distancia < DistanciaMinimaPontos)
return false;
}
}
}
return true;
}

//+------------------------------------------------------------------+
//| Verifica se o spread está aceitável |
//+------------------------------------------------------------------+
bool spreadAceitavel()
{
double spread = (SymbolInfoDouble(_Symbol, SYMBOL_ASK) - SymbolInfoDouble(_Symbol, SYMBOL_BID)) / SymbolInfoDouble(_Symbol, SYMBOL_POINT);
return (spread <= SpreadMaximo);
}

//+------------------------------------------------------------------+
//| Abre compra com proteção |
//+------------------------------------------------------------------+
void abrirCompra(double preco)
{
if(TimeCurrent() - ultimoErroEnvio < delayErroEnvioSegundos)
return;

if(!trade.Buy(loteBuyAtual, _Symbol, preco, 0, 0, "EA LoqBot Comprou!"))
{
Print("X Deu ruim na COMPRA: ", GetLastError(), " — EA LoqBot brochou na hora H");
ultimoErroEnvio = TimeCurrent();
}
else
Print("> COMPRA executada! O mercado vai ter que aguentar!");
}


//+------------------------------------------------------------------+
//| Abre venda com proteção |
//+------------------------------------------------------------------+
void abrirVenda(double preco)
{
if(TimeCurrent() - ultimoErroEnvio < delayErroEnvioSegundos)
return;

if(!trade.Sell(loteSellAtual, _Symbol, preco, 0, 0, "EA LoqBot Vendeu!"))
{
Print("X Deu ruim na VENDA: ", GetLastError(), " — Não aguentou e travou no meio");
ultimoErroEnvio = TimeCurrent();
}
else
Print("> VENDA executada! Foi sem cuspe e sem dó!");
}

//+------------------------------------------------------------------+
//| Fecha todas as posições |
//+------------------------------------------------------------------+
void fecharTodasOrdens()
{
for(int i = PositionsTotal() - 1; i >= 0; i--)
{
if(PositionGetTicket(i) > 0)
{
if(PositionGetString(POSITION_SYMBOL) == _Symbol)
{
ulong ticket = PositionGetInteger(POSITION_TICKET);
trade.PositionClose(ticket);
}
}
}

Print(">> Fechou tudo no lucro! Agora pode tirar o print e mandar no grupo!");
}

//+------------------------------------------------------------------+
//| Soma lucro flutuante da conta nesse ativo |
//+------------------------------------------------------------------+
double calcularLucroFlutuante()
{
double lucro = 0.0;
for(int i = PositionsTotal() - 1; i >= 0; i--)
{
if(PositionGetTicket(i) > 0)
{
if(PositionGetString(POSITION_SYMBOL) == _Symbol)
{
lucro += PositionGetDouble(POSITION_PROFIT);
}
}
}
return lucro;
}

//+------------------------------------------------------------------+
//| Inverte lógica de operação do Taka |
//+------------------------------------------------------------------+
void inverterLogica()
{
if(AtivarCompra && !AtivarVenda)
{
AtivarCompra = false;
AtivarVenda = true;
Print("[MODO] Chega de amor, agora é ódio: VENDA ATIVADA");
}
else if(AtivarVenda && !AtivarCompra)
{
AtivarCompra = true;
AtivarVenda = false;
Print("[MODO] Fim do ódio, volta pro carinho: COMPRA ATIVADA");
}
else
{
AtivarCompra = true;
AtivarVenda = false;
Print("[MODO] Robô bipolar ativado: voltando ao modo COMPRA");
}

ordensDesdeUltimaTroca = 0;
tempoUltimaTroca = TimeCurrent();
atualizarLabelModo();
atualizarPainelContador();
ChartRedraw();
}

//+------------------------------------------------------------------+
//| Atualiza o rótulo de modo atual na tela |
//+------------------------------------------------------------------+
void atualizarLabelModo()
{
string nome = "LabelModoAtual";
ObjectDelete(0, nome);

string texto = "";

if(AtivarCompra && !AtivarVenda)
texto = "MODO ATUAL: Comprando Igual Corno Apaixonado";
else if(AtivarVenda && !AtivarCompra)
texto = "MODO ATUAL: Vendendo com Ódio no Coração";
else
texto = "MODO ATUAL: Confuso Igual Sua Vida Amorosa";

if(ObjectCreate(0, nome, OBJ_LABEL, 0, 0, 0))
{
ObjectSetInteger(0, nome, OBJPROP_CORNER, CORNER_LEFT_UPPER);
ObjectSetInteger(0, nome, OBJPROP_XDISTANCE, 150);
ObjectSetInteger(0, nome, OBJPROP_YDISTANCE, 590);
ObjectSetInteger(0, nome, OBJPROP_FONTSIZE, 9);
ObjectSetInteger(0, nome, OBJPROP_COLOR, clrYellow);
ObjectSetString(0, nome, OBJPROP_TEXT, texto);
}
}

//+------------------------------------------------------------------+
//| Atualiza o painel com contagem de ordens |
//+------------------------------------------------------------------+
void atualizarPainelContador()
{
string obj = "ContadorOrdens";
ObjectDelete(0, obj);

string texto = " Compras: " + IntegerToString(contadorCompras) + " | Vendas: " + IntegerToString(contadorVendas);

if(ObjectCreate(0, obj, OBJ_LABEL, 0, 0, 0))
{
ObjectSetInteger(0, obj, OBJPROP_CORNER, CORNER_LEFT_UPPER);
ObjectSetInteger(0, obj, OBJPROP_XDISTANCE, 150);
ObjectSetInteger(0, obj, OBJPROP_YDISTANCE, 570);
ObjectSetInteger(0, obj, OBJPROP_FONTSIZE, 9);
ObjectSetInteger(0, obj, OBJPROP_COLOR, clrWhite);
ObjectSetString(0, obj, OBJPROP_TEXT, texto);
}
}

//+------------------------------------------------------------------+
//| Exibe o logo do EA no gráfico |
//+------------------------------------------------------------------+
void ShowLogo()
{
string objName = "LogoEA";

ObjectDelete(0, objName);
ChartSetInteger(0, CHART_FOREGROUND, true);

if(ObjectCreate(0, objName, OBJ_BITMAP_LABEL, 0, 0, 0))
{
ObjectSetString(0, objName, OBJPROP_BMPFILE, "::Images\\Loq_Bot.bmp");
ObjectSetInteger(0, objName, OBJPROP_CORNER, CORNER_LEFT_UPPER);
ObjectSetInteger(0, objName, OBJPROP_XDISTANCE, 250);
ObjectSetInteger(0, objName, OBJPROP_YDISTANCE, 20);
Print(" Logo do EA LoqBot exibida com sucesso.");
}
else
{
Print("Erro ao exibir logo. Código: ", GetLastError());
}
}

//+------------------------------------------------------------------+
//| Cria o botão Fecha Tudo com visual Taka |
//+------------------------------------------------------------------+
void CreateFechaTudoButton()
{
if(!EnableFechaTudoButton)
return;

ObjectDelete(0, FechaTudoBtnName);

if(!ObjectCreate(0, FechaTudoBtnName, OBJ_BUTTON, 0, 0, 0))
{
Print(" Não consegui criar o botão FechaTudo: ", GetLastError());
return;
}

ObjectSetInteger(0, FechaTudoBtnName, OBJPROP_CORNER, CORNER_RIGHT_UPPER);
ObjectSetInteger(0, FechaTudoBtnName, OBJPROP_XDISTANCE, 153);
ObjectSetInteger(0, FechaTudoBtnName, OBJPROP_YDISTANCE, 532);
ObjectSetInteger(0, FechaTudoBtnName, OBJPROP_XSIZE, 90);
ObjectSetInteger(0, FechaTudoBtnName, OBJPROP_YSIZE, 25);
ObjectSetString (0, FechaTudoBtnName, OBJPROP_TEXT, " Fecha Tudo");
ObjectSetInteger(0, FechaTudoBtnName, OBJPROP_FONTSIZE, 11);
ObjectSetInteger(0, FechaTudoBtnName, OBJPROP_COLOR, clrWhite);
ObjectSetInteger(0, FechaTudoBtnName, OBJPROP_BGCOLOR, clrFireBrick);
ObjectSetInteger(0, FechaTudoBtnName, OBJPROP_BORDER_TYPE, BORDER_RAISED);
ObjectSetInteger(0, FechaTudoBtnName, OBJPROP_BORDER_COLOR, clrBlack);
ObjectSetInteger(0, FechaTudoBtnName, OBJPROP_BACK, true);

Print(" Botão 'Fecha Tudo' apareceu no gráfico — só clicar se for homem!");
}

void CriarPainelLote()
{
// Campo de entrada para lote BUY
ObjectCreate(0, inputBuyObj, OBJ_EDIT, 0, 0, 0);
ObjectSetInteger(0, inputBuyObj, OBJPROP_CORNER, CORNER_LEFT_UPPER);
ObjectSetInteger(0, inputBuyObj, OBJPROP_XDISTANCE, 50);
ObjectSetInteger(0, inputBuyObj, OBJPROP_YDISTANCE, 620);
ObjectSetInteger(0, inputBuyObj, OBJPROP_XSIZE, 60);
ObjectSetInteger(0, inputBuyObj, OBJPROP_YSIZE, 20);
ObjectSetString(0, inputBuyObj, OBJPROP_TEXT, DoubleToString(loteBuyAtual, 2));

// Campo de entrada para lote SELL
ObjectCreate(0, inputSellObj, OBJ_EDIT, 0, 0, 0);
ObjectSetInteger(0, inputSellObj, OBJPROP_CORNER, CORNER_LEFT_UPPER);
ObjectSetInteger(0, inputSellObj, OBJPROP_XDISTANCE, 120);
ObjectSetInteger(0, inputSellObj, OBJPROP_YDISTANCE, 620);
ObjectSetInteger(0, inputSellObj, OBJPROP_XSIZE, 60);
ObjectSetInteger(0, inputSellObj, OBJPROP_YSIZE, 20);
ObjectSetString(0, inputSellObj, OBJPROP_TEXT, DoubleToString(loteSellAtual, 2));

// Botão de aplicar alterações
ObjectCreate(0, btnAplicarLote, OBJ_BUTTON, 0, 0, 0);
ObjectSetInteger(0, btnAplicarLote, OBJPROP_CORNER, CORNER_LEFT_UPPER);
ObjectSetInteger(0, btnAplicarLote, OBJPROP_XDISTANCE, 190);
ObjectSetInteger(0, btnAplicarLote, OBJPROP_YDISTANCE, 620);
ObjectSetInteger(0, btnAplicarLote, OBJPROP_XSIZE, 70);
ObjectSetInteger(0, btnAplicarLote, OBJPROP_YSIZE, 20);
ObjectSetString(0, btnAplicarLote, OBJPROP_TEXT, "Aplicar");
ObjectSetInteger(0, btnAplicarLote, OBJPROP_FONTSIZE, 10);
ObjectSetInteger(0, btnAplicarLote, OBJPROP_BGCOLOR, clrRoyalBlue);
ObjectSetInteger(0, btnAplicarLote, OBJPROP_COLOR, clrWhite);
}

//+------------------------------------------------------------------+
//| Suporte a Indicador Externo + Leitura de Preset |
//+------------------------------------------------------------------+
void InitializeExternalSupport()
{
if(EnableExternalIndicator)
{
double check = iCustom(_Symbol, PERIOD_CURRENT, ExternalIndicatorName, 0, 0);
if(check == 0.0 && GetLastError() == ERR_INDICATOR_CANNOT_CREATE)
Print("Indicador Externo não encontrado: ", ExternalIndicatorName);
else
Print(" Indicador Externo carregado com sucesso: ", ExternalIndicatorName);
}

if(EnablePresetReader)
{
int handle = FileOpen(ExternalPresetFile, FILE_READ | FILE_TXT | FILE_ANSI);
if(handle != INVALID_HANDLE)
{
Print(" Arquivo de preset encontrado: ", ExternalPresetFile);
FileClose(handle);
}
else
{
Print(" Arquivo de preset NÃO encontrado: ", ExternalPresetFile);
}
}
}

//+------------------------------------------------------------------+
//| Lê arquivo linha por linha e imprime no Log |
//+------------------------------------------------------------------+
void ReadExternalPreset()
{
if(!EnablePresetReader) return;

int handle = FileOpen(ExternalPresetFile, FILE_READ | FILE_TXT | FILE_ANSI);
if(handle == INVALID_HANDLE)
{
Print(" Falha ao abrir preset externo: ", ExternalPresetFile);
return;
}

while(!FileIsEnding(handle))
{
string linha = FileReadString(handle);
Print(" Linha lida do preset: ", linha);
}

FileClose(handle);
}


// Retorna o lucro flutuante apenas do símbolo atual
double GetSymbolProfit()
{
double lucro = 0.0;
for(int i = PositionsTotal() - 1; i >= 0; i--)
{
if(PositionGetTicket(i) > 0)
{
if(PositionGetString(POSITION_SYMBOL) == _Symbol)
{
lucro += PositionGetDouble(POSITION_PROFIT);
}
}
}
return lucro;
}


void BlinkFloatingProfit()
{
string objName = "FloatingProfitLabel";

// Cria o objeto se ainda não existir
if(ObjectFind(0, objName) < 0)
{
ObjectCreate(0, objName, OBJ_LABEL, 0, 0, 0);
ObjectSetInteger(0, objName, OBJPROP_CORNER, CORNER_LEFT_UPPER);
ObjectSetInteger(0, objName, OBJPROP_XDISTANCE, 1451); // ajuste se quiser direita, esquerda
ObjectSetInteger(0, objName, OBJPROP_YDISTANCE, 510);
ObjectSetInteger(0, objName, OBJPROP_FONTSIZE, 9);
ObjectSetString(0, objName, OBJPROP_FONT, "Arial");
}



// Lucro flutuante do ativo atual
double floatingProfit = GetSymbolProfit();
string fpText = " (" + Symbol() + "): $ " + DoubleToString(floatingProfit, 2);
ObjectSetString(0, objName, OBJPROP_TEXT, fpText);

// Paleta de cores baseada no lucro/prejuízo
color corAtual;
if(floatingProfit >= 0)
corAtual = (fpBlinkColorIndex % 2 == 0) ? clrLime : clrWhite;
else
corAtual = (fpBlinkColorIndex % 2 == 0) ? clrRed : clrWhite;

ObjectSetInteger(0, objName, OBJPROP_COLOR, corAtual);
fpBlinkColorIndex++;
}


//+------------------------------------------------------------------+
//| Captura eventos do gráfico, como clique de botão |
//+------------------------------------------------------------------+
void OnChartEvent(const int id,
const long &lparam,
const double &dparam,
const string &sparam)
{
if(id == CHARTEVENT_OBJECT_CLICK && sparam == FechaTudoBtnName)
{
Print(" Botão 'Fecha Tudo' clicado! Solicitando confirmação...");

int resposta = MessageBox(" Você realmente quer FECHAR TODAS as ordens Abertas DESSE ATIVO?\n\nEssa ação não pode ser desfeita e vai doer na Alma da Conta SACANA!",
"Confirmação de Fechamento", MB_YESNO | MB_ICONQUESTION);

if(resposta == IDYES)
{
Print(" Confirmação recebida. Fechando geral como pedido!");
fecharTodasOrdens();
contadorCompras = 0;
contadorVendas = 0;
ordensDesdeUltimaTroca = 0;
tempoUltimaTroca = TimeCurrent();
}
else
{
Print(" Ufa! Cancelaram o fechamento geral. A conta agradece.");
}
}
}



void ExecutarRobo2()
{
if(!AtivarRobo2) return;

if(TimeCurrent() < blockUntil_R2)
{
Comment(" ROBO2 bloqueado até: ", TimeToString(blockUntil_R2, TIME_DATE | TIME_MINUTES));
return;
}

if(ordersClosed_R2 && TimeCurrent() >= blockUntil_R2)
{
ordersClosed_R2 = false;
Print("ROBO2: Bloqueio finalizado. Pronto para novo ciclo.");
Comment("");
}

if(ordersClosed_R2) return;

double lucroFlutuante = AccountInfoDouble(ACCOUNT_EQUITY) - AccountInfoDouble(ACCOUNT_BALANCE);

if(lucroFlutuante >= ProfitThreshold_R2)
{
Print(" ROBO2: Lucro flutuante de $", DoubleToString(lucroFlutuante, 2),
" → fechando todas as ordens da conta!");
CloseAllOrders_Robo2();
ordersClosed_R2 = true;
blockUntil_R2 = TimeCurrent() + BlockTimeMinutes_R2 * 60;
}
}


void CloseAllOrders_Robo2()
{
// Fecha ordens de mercado
for(int i = PositionsTotal() - 1; i >= 0; i--)
{
if(PositionGetTicket(i) > 0)
{
string sym = PositionGetString(POSITION_SYMBOL);
if(!trade.PositionClose(sym, Slippage_R2))
Print("Erro ao fechar posição de ", sym, " - Erro: ", GetLastError());
}
}

// Deleta ordens pendentes
for(int i = OrdersTotal() - 1; i >= 0; i--)
{
if(OrderGetTicket(i) > 0)
{
ulong ticket = OrderGetTicket(i);
if(!trade.OrderDelete(ticket))
Print("Erro ao excluir ordem pendente #", ticket, " - Erro: ", GetLastError());
}
}
}

Registrato sulla MQL5.community