Gama_v1/Desenvolvimento_v1_0/S2_Motor_v1_0.mqh

<EFBFBD><EFBFBD>//+------------------------------------------------------------------+
//|                                                S2_Motor_v1_0.mqh |
//|                                                             GAMA |
//|                                             HEDGING HORN CAPITAL |
//|                                     https://www.hhcapital.com.br |
//+------------------------------------------------------------------+
#property copyright "Copyright 2023, HEDGING HORN CAPITAL"
#property link      "https://www.hhcap<00>tal.com.br"
#property version   "GAMA DESENVOLVIMENTO v1_0"
#property description "LFT MEAN REVERSION. MINI INDICE."

//+===================================================================================================================================================================================+
//| 0 - SESSAO DE CABECALHO / ADMISSAO                                                                                                                                                
//+===================================================================================================================================================================================+
//+------------------------------------------------------------------+
//| 0.1 - IMPORTACOES                                                |
//+------------------------------------------------------------------+
#include <Expert/Expert.mqh>
#include <Trade/Trade.mqh>
#include <Trade/SymbolInfo.mqh>
#include "MarketBook.mqh"
#include "S0_Admissao_v1_0.mqh"
#include "S3_Freios_v1_0.mqh"
#include "S4_Cambio_v1_0.mqh"
#include "S5_Direcao_v1_0.mqh"
#include "S6_Transmissao_v1_0.mqh"

//+===================================================================================================================================================================================+
//| 2 - SESSAO DE FAZER NEGOCIACOES / MOTOR                                                                                                                            
//+===================================================================================================================================================================================+
//+------------------------------------------------------------------+
//| 2.1 - FUNCAO QUE FAZ NEGOCIACOES                                 |
//+------------------------------------------------------------------+
void FazTrades(gerenciador &Gerenciador, operacao &Operacao, fluido &Fluidos, slot &SlotsC[], slot &SlotsV[])
{  
   AtualizaOrdens(Operacao, Fluidos);
   ExecutaSlotsDisponiveis();
   AtualizaTelemetria(Gerenciador, Operacao, Fluidos, SlotsC, SlotsV);
   Operacao.countFechaDia == 0;
   
   return;
}

//+------------------------------------------------------------------+
//| 2.2 - FUNCAO QUE ATUALIZA ORDENS                                 |
//+------------------------------------------------------------------+
void AtualizaOrdens(operacao &Operacao, fluido &Fluidos)
{
   ulong ticket = 0;
   MqlDateTime horarioMQL_ordem;
   
   for(int i=OrdersTotal()-1;i>=0;i--)
   {
      ticket = OrderGetTicket(i);
      
      ushort horarioOrdem = 0;
      ushort horarioShortAtual = 0;
      
      OrderSelect(ticket);
      double tamanho = OrderGetDouble(ORDER_VOLUME_INITIAL); 
      
      TimeToStruct(TimeCurrent(), Operacao.horarioMQL_atual);
      TimeToStruct(OrderGetInteger(ORDER_TIME_SETUP), horarioMQL_ordem);
      horarioOrdem = horarioMQL_ordem.hour*60*60 + horarioMQL_ordem.min*60 + horarioMQL_ordem.sec;
      horarioShortAtual = Operacao.horarioMQL_atual.hour*60*60 + Operacao.horarioMQL_atual.min*60 + Operacao.horarioMQL_atual.sec;
   //   Print("horarioAtual: ", horarioShortAtual, "  horarioOrdem: ", horarioOrdem, "  Fluidos.lifetime: ", Fluidos.lifetimeOrdem);
      if((horarioShortAtual - horarioOrdem) > Fluidos.TOr) 
      {
         bool retCancelou = Operacao.negocio.OrderDelete(ticket);   
         if(retCancelou == true) Operacao.numeroContratos = Operacao.numeroContratos - tamanho; 
       //  Print("Cancelou ordem aberta por expira<00><00>o.");
      }
   }
}

//+------------------------------------------------------------------+
//| 2.3 - FUNCAO QUE ATUALIZA E EXECUTA OS SLOTS DISPONVEIS DE ORDENS|
//+------------------------------------------------------------------+
void ExecutaSlotsDisponiveis()
{
   //Avanca os status dos slots
   for(int i=0; i<Fluidos.niveis; i++)
   {
      Fluidos.iSlot = i;
      
      //C
      TrocaMarcha(Operacao, Fluidos, SlotsC);
      
      if(SlotsC[i].statusCambio == 1)
      {
         CalculaPrecoOrdem(Operacao, Fluidos, SlotsC);
         CalculaQuantidade(Fluidos, SlotsC);
      }
      
      ExecutaSlotsCompra(Operacao, Fluidos, SlotsC, ArrayTick, i);
      
      //V
      TrocaMarcha(Operacao, Fluidos, SlotsV); 
      
      if(SlotsV[i].statusCambio == 1)
      {
         CalculaPrecoOrdem(Operacao, Fluidos, SlotsV);
         CalculaQuantidade(Fluidos, SlotsV); 
      }
      
      ExecutaSlotsVenda(Operacao, Fluidos, SlotsV, ArrayTick, i);
   }
}

//+------------------------------------------------------------------+
//| 2.4 - FUNCAO QUE VARRE SLOTS DE COMPRA E ENVIA ORDENS            |
//+------------------------------------------------------------------+
void ExecutaSlotsCompra(operacao &Operacao, fluido &Fluidos, slot &SlotsC[], MqlTick &ArrayTick[], int i)
{    
   MqlTick tick;
   double last=0;

   if(SymbolInfoTick(_Symbol,tick)) last=tick.last;
   
   //Print("status motor: ",SlotsC[i].statusMotor);
   switch(SlotsC[i].statusMotor)
   {
      case 1 : 
         if(VerificaRiscosNivel2C(Operacao, Fluidos) == true) break;
          
         if(SlotsC[i].precoEnvio < last)
         {
            CompraLimite(Operacao, SlotsC, i);
           // Print("Mandou ordem de compra limite.");
           
            if(Operacao.result.retcode == 10009)
            {
               //SlotsC[i].idOrdem = Operacao.result.order;
               OrderSelect(SlotsC[i].idOrdem);
               TimeToStruct(TimeCurrent(),SlotsC[i].cronometro);
            }
            else 
            {
               SlotsC[i].statusCambio = 0;
               SlotsC[i].statusMotor = 0;
            }
         }
         break;
      case 3 :
         CancelaOrdemAberta(Operacao, SlotsC[i].idOrdem);
        // Print("Cancelou ordem de compra limite.");
         break;        
      default : 
         break;
   }  
}

//+------------------------------------------------------------------+
//| 2.5 - FUNCAO QUE VARRE SLOTS DE VENDA E ENVIA ORDENS             |
//+------------------------------------------------------------------+
void ExecutaSlotsVenda(operacao &Operacao, fluido &Fluidos, slot &SlotsV[], MqlTick &ArrayTick[], int i)
{  
   MqlTick tick;
   double last=0;

   if(SymbolInfoTick(_Symbol,tick)) last=tick.last;
   
   //Print("status motor: ",SlotsV[i].statusMotor);
   switch(SlotsV[i].statusMotor)
   {
      case 1 : 
         if(VerificaRiscosNivel2V(Operacao, Fluidos) == true)  break;
         
         if(SlotsV[i].precoEnvio > last)
         {
            VendaLimite(Operacao, SlotsV, i);
          //  Print("Mandou ordem de venda limite.");
            
            if(Operacao.result.retcode == 10009)
            {
               //Avanca o status do slot para enviado
               //SlotsV[i].idOrdem = Operacao.result.order;
               OrderSelect(SlotsV[i].idOrdem);
               TimeToStruct(TimeCurrent(), SlotsV[i].cronometro);
            }
            else
            {
               SlotsV[i].statusCambio = 0;
               SlotsV[i].statusMotor = 0;
            }
         }
         break;
      case 3 :
         CancelaOrdemAberta(Operacao, SlotsV[i].idOrdem);
       //  Print("Cancelou ordem de compra limite.");
         break;       
      default : 
         break;
   }  
}

//+------------------------------------------------------------------+
//| 2.6 - FUNCAO QUE CALCULA O TEMPO LIMITE DE EXPIRACAO DE ORDEM C  |
//+------------------------------------------------------------------+
int CalculaTempoExpiraOrdemCompra(operacao &Operacao, fluido &Fluidos, int depth)
{
   int tempo = 0;
 
   tempo = 60;
   return tempo;
}

//+------------------------------------------------------------------+
//| 2.7 - FUNCAO QUE CALCULA O TEMPO LIMITE DE EXPIRACAO DE ORDEM V  |
//+------------------------------------------------------------------+
int CalculaTempoExpiraOrdemVenda(operacao &Operacao, fluido &Fluidos, int depth)
{
   int tempo = 0;
   
   tempo = 60;
   return tempo;
}

//+------------------------------------------------------------------+
//| 2.8 - FUNCAO QUE ATUALIZA TELEMETRIA                             |
//+------------------------------------------------------------------+
void AtualizaTelemetria(gerenciador &Gerenciador, operacao &Operacao, fluido &Fluidos, slot &SlotsC[], slot &SlotsV[])
{
   //ATUALIZA TELEMETRIA
   Comment(
           "===GERENCIAMENTO P&L===", "\n" +
           "CAPITAL BRUTO FECHADO: ", Gerenciador.capitalFechado, "\n" +
           "CAPITAL BRUTO ABERTO: ", Gerenciador.capitalAberto, "\n" +
           "LUCRO BRUTO FECHADO: ", Gerenciador.lucroBrutoFechado, "\n" +
           "LUCRO BRUTO ABERTO: ", Gerenciador.lucroBrutoAberto, "\n" +
           "LUCRO BRUTO COMPOSTO: ", Gerenciador.lucroBrutoComposto, "\n" +
           "LUCRO LIQUIDO: ", Gerenciador.lucroLiquido, "\n" +        
           "NUMERO DE CONTRATOS (compra+venda): ", Operacao.numeroContratos - (2*(Fluidos.rajada*Fluidos.niveis)), "\n" +
           "CUSTO: ", (Operacao.numeroContratos - (2*Fluidos.rajada*Fluidos.niveis)) * (Fluidos.c * 2), "\n" +
           "INVENTARIO: ", Fluidos.q);
           
   
   Print(NormalizeDouble(Fluidos.media,0),"/",SlotsC[0].spreadEnvio,"/",SlotsC[0].spreadAlvo,"/",SlotsV[0].spreadEnvio,"/",SlotsV[0].spreadAlvo,"/",Gerenciador.lucroBrutoComposto);
   
   return;
}

//+===================================================================================================================================================================================+
//| FIM DO PROGRAMA                                                                                                   
//+===================================================================================================================================================================================+