Ut Bot Indicator

Evolutionieren Sie Ihren Handel mit dem UT Alert Bot Indikator für MQL4

Der UT Alert Bot Indicator ist Ihr ultimativer Handelsbegleiter, der sorgfältig entwickelt wurde, um Ihnen in der schnelllebigen Welt der Finanzmärkte einen Vorteil zu verschaffen. Angetrieben durch das renommierte UT-System, kombiniert dieses innovative Tool fortschrittliche Analysen, Echtzeit-Warnungen und anpassbare Funktionen, um sicherzustellen, dass Sie nie eine profitable Gelegenheit verpassen. Ob Sie nun mit Devisen, Aktien, Indizes oder Rohstoffen handeln, der UT Alert Bot Indicator ist Ihr Schlüssel zu intelligenteren, schnelleren und präziseren Handelsentscheidungen.

Hier ist der Quellcode eines einfachen Expert Advisors, der auf Basis der Signale von Ut Bot Alert arbeitet.

#property copyright "This EA is only education purpose only use it ur own risk"
#property link      "https://sites.google.com/view/automationfx/home"
#property version   "1.00"
#property strict
//+------------------------------------------------------------------+
// Expert iniputs                                                    |
//+------------------------------------------------------------------+
input string             EA_Setting              =  "";                   // General settings
input int                magic_number            = 1234;                 // Magic number for trade identification
input double             fixed_lot_size          = 0.01;                 // Fixed lot size
input double             StopLoss                = 0;                    // Stop loss level (in pips)
input double             TakeProfit              = 0;                   // Take profit level (in pips)
input double             LotMultiplier = 2.0; // Multiplier for martingale strategy


string Name_Indicator       = "Market/UT Bot Indicator.ex4";  // Name of the custom indicator
int bufferToBuy2 = 0;                      // Buffer index for buy signals
int bufferToSell2 = 1;                     // Buffer index for sell signals
double current_lot_size;                   // Current lot size
int LastProf = 0;                          // 1 = profit, -1 = loss, 0 = no history


// Enum to represent candle indices
enum candle
  {
   curr = -1,  // Current candle
   prev = 0    // Previous closed candle
  };

// Indicator settings
input string Indicator = "== Market/UT Bot Indicator.ex4 ==";    // Indicator title
static input string _Properties_ = "Automationfx";  // Expert properties
input double         Key_value          =  2;         // Key value for indicator calculation
input double         atrPeriods         =  14;       // ATR periods for indicator
input bool           h                  = false;     // Use Heiken Ashi candles for signals
int                  s                  = prev;     // Show arrows on previous candle
int                  p                  = 20;                         // Arrow position (in points)
input int            b                  = 10;                 // Candle period for calculations
string T_0 = "== Draw Trade ==";    // Trade drawing title
input bool          drawTradeON         = false;

//+------------------------------------------------------------------+
//|  get indicator                                                                |
//+------------------------------------------------------------------+
double UT_Bot(int buffer, int _candle)
  {
// Call the custom indicator and return its value
   return iCustom(NULL, 0, "Market/UT Bot Indicator.ex4",Indicator, Key_value, atrPeriods, h, s, p, b, T_0, drawTradeON, buffer, _candle);
  }


//+------------------------------------------------------------------+
// Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
   ChartSetInteger(0, CHART_SHOW_GRID, false);
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//---

  }
//+------------------------------------------------------------------+
//| for calculation buy                                 |
//+------------------------------------------------------------------+
int BuyCount()
  {
   int counter=0;
   for(int i=0; i<OrdersTotal(); i++)
     {
      if(OrderSelect(i, SELECT_BY_POS)==false)
         continue;
      if(OrderSymbol()!=_Symbol)
         continue;
      if(OrderMagicNumber()!=magic_number)
         continue;
      if(OrderType()==OP_BUY)
         counter++;
     }
   return counter;
  }

//+------------------------------------------------------------------+
//| for calculation sell                                                                 |
//+------------------------------------------------------------------+
int SellCount()
  {
   int counter=0;
   for(int i=0; i<OrdersTotal(); i++)
     {
      if(OrderSelect(i, SELECT_BY_POS)==false)
         continue;
      if(OrderSymbol()!=_Symbol)
         continue;
      if(OrderMagicNumber()!=magic_number)
         continue;
      if(OrderType()==OP_SELL)
         counter++;
     }
   return counter;
  }



//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
// Check if a new bar has formed
   if(!isNewBar())
      return;
// Buy condition
   bool buy_condition = true;
   buy_condition &= (BuyCount() == 0);
   buy_condition &= (UT_Bot(0, 1) != EMPTY_VALUE); // Ensure valid check

   if(buy_condition)
     {
      CloseSell();
      Buy();
     }
// Sell condition
   bool sell_condition = true;
   sell_condition &= (SellCount() == 0);
   sell_condition &= (UT_Bot(1, 1) != EMPTY_VALUE); // Ensure valid check

   if(sell_condition)
     {
      CloseBuy();
      Sell();
     }

  }

// Function to calculate lot size based on the last trade
void Lot()
  {
// Analyze the last order in history
   if(OrderSelect(OrdersHistoryTotal() - 1, SELECT_BY_POS, MODE_HISTORY))
     {
      if(OrderSymbol() == _Symbol && OrderMagicNumber() == magic_number)
        {
         if(OrderProfit() > 0)
           {
            LastProf = 1;                   // Last trade was profitable
            current_lot_size = fixed_lot_size; // Reset to fixed lot size
           }
         else
           {
            LastProf = -1;                  // Last trade was a loss
            current_lot_size = NormalizeDouble(current_lot_size * LotMultiplier, 2);
           }
        }
     }
   else
     {
      // No previous trades, use the fixed lot size
      LastProf = 0;
      current_lot_size = fixed_lot_size;
     }
  }



datetime timer=NULL;
bool isNewBar()
  {
   datetime candle_start_time= (int)(TimeCurrent()/(PeriodSeconds()))*PeriodSeconds();
   if(timer==NULL) {}
   else
      if(timer==candle_start_time)
         return false;
   timer=candle_start_time;
   return true;
  }

//+------------------------------------------------------------------+
//|  open buy trades                                                                |
//+------------------------------------------------------------------+
void Buy()
  {
   Lot();
   double StopLossLevel;
   double TakeProfitLevel;
// Calculate the stop loss and take profit levels based on input values
   if(StopLoss>0)
      StopLossLevel=Bid-StopLoss*Point;
   else
      StopLossLevel=0.0;
   if(TakeProfit>0)
      TakeProfitLevel=Ask+TakeProfit*Point;
   else
      TakeProfitLevel=0.0;


   if(OrderSend(_Symbol, OP_BUY, current_lot_size, Ask, 3, StopLossLevel,TakeProfitLevel, NULL, magic_number, 0, clrNONE) == -1)
     {
      Print("Error Executing Buy Order: ", GetLastError());
     }
  }

//+------------------------------------------------------------------+
//|  open sell trades                                                                |
//+------------------------------------------------------------------+
void Sell()
  {
   Lot();
   double StopLossLevel1;
   double TakeProfitLevel2;
// Calculate the stop loss and take profit levels based on input values
   if(StopLoss>0)
      StopLossLevel1=Ask+StopLoss*Point;
   else
      StopLossLevel1=0.0;
   if(TakeProfit>0)
      TakeProfitLevel2=Bid-TakeProfit*Point;
   else
      TakeProfitLevel2=0.0;


   if(OrderSend(_Symbol, OP_SELL, current_lot_size, Bid, 3, StopLossLevel1,TakeProfitLevel2, NULL, magic_number, 0, clrNONE) == -1)
     {
      Print("Error Executing Sell Order: ", GetLastError());
     }
  }


//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CloseBuy()
  {
   for(int i=OrdersTotal()-1; i>=0; i--)
     {
      if(OrderSelect(i, SELECT_BY_POS)==false)
         continue;
      if(OrderSymbol()!=_Symbol)
         continue;
      if(OrderMagicNumber()!=magic_number)
         continue;
      if(OrderType()==OP_BUY)
         if(OrderClose(OrderTicket(), OrderLots(), Bid, 3, clrNONE)==false)
           {
            Print("Error Closing Position: ", GetLastError());
           }
     }
  }

//+------------------------------------------------------------------+
//|  close all positions currunly not use                                                                |
//+------------------------------------------------------------------+
void CloseSell()
  {
   for(int i=OrdersTotal()-1; i>=0; i--)
     {
      if(OrderSelect(i, SELECT_BY_POS)==false)
         continue;
      if(OrderSymbol()!=_Symbol)
         continue;
      if(OrderMagicNumber()!=magic_number)
         continue;
      if(OrderType()==OP_SELL)
         if(OrderClose(OrderTicket(), OrderLots(), Ask, 3, clrNONE)==false)
           {
            Print("Error Closing Position: ", GetLastError());
           }
     }
  }
//+------------------------------------------------------------------+