Nivelesfibonacci2

NIVELESFIBONACCI2.12 — Órdenes Pendientes sobre Niveles Fibonacci Personalizados

Este script para MetaTrader 5 permite colocar automáticamente órdenes pendientes de compra o venta utilizando como referencia los niveles Fibonacci horizontales previamente dibujados en el gráfico.

El script está diseñado para funcionar conjuntamente con NIVELESFIBONACCI1.1, aunque puede utilizar cualquier conjunto de líneas horizontales que siga la misma estructura de nombres mediante el prefijo configurado.

La primera herramienta calcula los precios correspondientes a los niveles Fibonacci y dibuja las líneas en el gráfico. Esta segunda herramienta utiliza esas líneas como referencia para colocar automáticamente las órdenes pendientes.

¿Cómo funciona?

El usuario configura:

• Dirección de las órdenes: BUY o SELL.

• Tamaño del lote.

• Take Profit opcional.

• Stop Loss opcional.

• Niveles Fibonacci que desea operar.

• Prefijo utilizado para identificar las líneas.

• Magic Number.

• Comentario de las órdenes.

El script busca en el gráfico las líneas cuyo nombre comience por el prefijo indicado en:

InpPrefix

Por defecto:

FiboCustom_

Por ejemplo, si el primer script ha creado:

FiboCustom_0.0 FiboCustom_23.6 FiboCustom_38.2 FiboCustom_50.0 FiboCustom_61.8 FiboCustom_100.0 FiboCustom_161.8

el segundo script puede seleccionar únicamente los niveles que se desean utilizar.

Ejemplo:

InpTargetLevels = "0; 23.6; 38.2; 61.8"

Los demás niveles serán ignorados.

Determinación automática del tipo de orden

El tipo de orden pendiente se determina automáticamente en función de la dirección seleccionada y de la posición del nivel respecto al precio actual del mercado.

Órdenes BUY

Si se selecciona:

DIR_BUY

el script utiliza:

Buy Limit

Cuando el precio de la línea está por debajo del precio Ask actual.

Precio línea < Ask

Se coloca una:

BUY LIMIT

Buy Stop

Cuando el precio de la línea está por encima del precio Ask actual.

Precio línea > Ask

Se coloca una:

BUY STOP

Órdenes SELL

Si se selecciona:

DIR_SELL

el script utiliza:

Sell Limit

Cuando el precio de la línea está por encima del precio Bid actual.

Precio línea > Bid

Se coloca una:

SELL LIMIT

Sell Stop

Cuando el precio de la línea está por debajo del precio Bid actual.

Precio línea < Bid

Se coloca una:

SELL STOP

De esta forma, el usuario no necesita seleccionar manualmente entre Limit y Stop. El script determina automáticamente el tipo de orden según la posición del nivel Fibonacci respecto al mercado.

Ejemplo de funcionamiento

Supongamos que el gráfico contiene las siguientes líneas:

FiboCustom_0.0 FiboCustom_23.6 FiboCustom_38.2 FiboCustom_50.0 FiboCustom_61.8 FiboCustom_100.0

Y el usuario configura:

Dirección: BUY
Lote: 0.01
Niveles: 0; 23.6; 38.2; 50; 61.8

El script localizará esas líneas, obtendrá sus precios y decidirá automáticamente si cada una corresponde a una Buy Limit o una Buy Stop dependiendo del precio Ask actual.

Por tanto, un mismo conjunto de niveles Fibonacci puede generar diferentes tipos de órdenes dependiendo de dónde se encuentre actualmente el mercado.

Take Profit y Stop Loss

El script permite introducir opcionalmente un precio de Take Profit y Stop Loss.

Sin Take Profit

InpTakeProfit = 0.0

No se establece TP.

Sin Stop Loss

InpStopLoss = 0.0

No se establece SL.

Cuando se introduce un precio superior a 0.0 , el valor se normaliza automáticamente utilizando los decimales del símbolo:

_Digits

Esto permite adaptar los precios a instrumentos con diferentes cantidades de decimales.

Selección de niveles

Los niveles se introducen mediante:

InpTargetLevels

separados por ; .

Por ejemplo:

0; 23.6; 38.2; 50; 61.8

También pueden utilizarse niveles superiores a 100% o niveles negativos, siempre que las correspondientes líneas existan en el gráfico.

Por ejemplo:

-61.8; 0; 23.6; 38.2; 50; 61.8; 100; 161.8; 261.8; 423.6

El script solamente operará los niveles seleccionados que encuentre mediante el prefijo configurado.

Identificación mediante prefijo

El parámetro:

InpPrefix

permite determinar qué objetos del gráfico serán considerados.

Valor predeterminado:

FiboCustom_

Por ejemplo:

FiboCustom_23.6 FiboCustom_50.0 FiboCustom_61.8

serán reconocidos.

Esta característica permite mantener separadas las líneas utilizadas por esta herramienta de otros objetos existentes en el gráfico.

Magic Number

El parámetro:

InpMagicNumber

permite identificar las órdenes creadas por el script.

Valor predeterminado:

123456

El Magic Number resulta especialmente útil para diferenciar estas órdenes de otras órdenes pendientes que puedan existir en la misma cuenta.

Comentario de las órdenes

El parámetro:

InpOrderComment

permite establecer el comentario asociado a las órdenes.

Valor predeterminado:

Fibo_Pending

Esto facilita su identificación dentro de MetaTrader 5.

Cancelación de órdenes pendientes

El parámetro:

InpAction

permite seleccionar entre dos acciones.

ACTION_PLACE

Coloca las órdenes pendientes correspondientes a los niveles seleccionados.

ACTION_DELETE

Cancela las órdenes pendientes que cumplan simultáneamente estas condiciones:

• Pertenecen al símbolo actual.

• Tienen el Magic Number indicado en InpMagicNumber .

Esto permite eliminar las órdenes pendientes gestionadas por este script sin afectar a las órdenes pertenecientes a otros símbolos o Magic Numbers.

Relación con NIVELESFIBONACCI1.1

Los dos scripts pueden utilizarse como un sistema de dos etapas:

NIVELESFIBONACCI1.1 ↓ Calcula los precios Fibonacci ↓ Dibuja las líneas horizontales ↓ NIVELESFIBONACCI2.12 ↓ Lee las líneas por prefijo ↓ Selecciona los niveles indicados ↓ Obtiene sus precios ↓ Determina automáticamente Limit / Stop ↓ Coloca las órdenes pendientes

Por ejemplo:

Primera herramienta

Punto A → 1.16594 = 100%
Punto B → 1.16363 = 423.6%

La primera herramienta calcula los precios correspondientes a:

0% 23.6% 38.2% 50% 61.8% 100% 161.8% 261.8% 423.6%

y los dibuja en el gráfico.

Posteriormente, la segunda herramienta puede seleccionar, por ejemplo:

23.6; 38.2; 50; 61.8

y colocar las órdenes pendientes directamente sobre esos precios.

Características principales

• Colocación masiva de órdenes pendientes sobre niveles Fibonacci.

• Compatible con niveles Fibonacci personalizados.

• Selección independiente de los niveles que se desean operar.

• Soporte para órdenes Buy Limit.

• Soporte para órdenes Buy Stop.

• Soporte para órdenes Sell Limit.

• Soporte para órdenes Sell Stop.

• Determinación automática del tipo de orden según el precio actual.

• Lectura de las líneas mediante un prefijo configurable.

• Compatible con diferentes números de decimales mediante _Digits .

• Normalización automática de los precios.

• Take Profit opcional.

• Stop Loss opcional.

• Magic Number configurable.

• Comentario de órdenes configurable.

• Función para cancelar las órdenes pendientes gestionadas por el Magic Number.

• No requiere indicadores externos.

• No requiere DLL.

Importante

Este script no calcula los niveles Fibonacci por sí mismo.

Utiliza los precios de las líneas horizontales existentes en el gráfico como niveles de entrada para las órdenes pendientes.

Para utilizarlo conjuntamente con NIVELESFIBONACCI1.1, ambos scripts deben utilizar el mismo prefijo, por defecto:

FiboCustom_

El script tampoco genera señales de compra o venta mediante análisis técnico. La dirección de las órdenes ( BUY o SELL ) es seleccionada manualmente por el usuario.

La colocación de órdenes implica riesgo financiero. El comportamiento final de una orden pendiente también depende de las condiciones de mercado, las reglas del bróker, la distancia mínima de órdenes, volumen permitido, stops level y demás restricciones del símbolo.

Versión: 2.12
Plataforma: MetaTrader 5
Tipo: Script
Autor: SPC

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

//|                                        NIVELESFIBONACCI2.12.mq5 |

//|                                                              SPC |

//|                       https://www.mql5.com/es/users/calimero1166 |

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

#property copyright "SPC"

#property link      "https://www.mql5.com/es/users/calimero1166"

#property version   "2.12"

#property description "Script para la colocación masiva o cancelación selectiva de órdenes pendientes (Limit/Stop) según niveles Fibonacci trazados por prefijo."

#property script_show_inputs

#include <Trade\Trade.mqh>

//--- Enumeración para la acción principal del script

enum ENUM_SCRIPT_ACTION

  {

   ACTION_PLACE  = 0, // Colocar Órdenes Pendientes

   ACTION_DELETE = 1  // Cancelar Órdenes Pendientes

  };

//--- Enumeración para la dirección de las órdenes

enum ENUM_ORDER_DIRECTION

  {

   DIR_BUY  = 0, // Compras Pendientes

   DIR_SELL = 1  // Ventas Pendientes

  };

//--- Parámetros de Entrada

input group "=== Acción Principal ==="

input ENUM_SCRIPT_ACTION InpAction       = ACTION_PLACE; // Acción a realizar

input group "=== Configuración Operativa ==="

input ENUM_ORDER_DIRECTION InpDirection   = DIR_BUY;      // Dirección de las órdenes

input double               InpLotSize     = 0.01;         // Volumen del lote por orden

input double               InpTakeProfit  = 0.0;          // Take Profit manual en precio (0.0 = Sin TP)

input double               InpStopLoss    = 0.0;          // Stop Loss manual en precio (0.0 = Sin SL)

input group "=== Selección de Niveles y Prefijo ==="

input string               InpTargetLevels = "0; 23.6; 38.2; 50; 61.8"; // Niveles Fibo a operar (Separados por ;)

input string               InpPrefix       = "FiboCustom_";             // Prefijo de las líneas a buscar

input group "=== Configuración Avanzada ==="

input ulong                InpMagicNumber  = 123456;       // Magic Number para identificar las órdenes

input string               InpOrderComment = "Fibo_Pending"; // Comentario para las órdenes

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

//| Script program start function                                    |

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

void OnStart()

  {

   CTrade trade;

   trade.SetExpertMagicNumber(InpMagicNumber);

   // --- MODO 1: CANCELAR ÓRDENES PENDIENTES ---

   if(InpAction == ACTION_DELETE)

     {

      int deletedCount = DeletePendingOrders(trade, InpMagicNumber);

      PrintFormat("NIVELESFIBONACCI2.12 (v2.12): Se han eliminado %d órdenes pendientes con Magic %d en %s.", deletedCount, InpMagicNumber, _Symbol);

      return;

     }

   // --- MODO 2: COLOCAR ÓRDENES PENDIENTES ---

   // 1. Procesar el texto de niveles a buscar

   double targetLevels[];

   ushort u_sep = StringGetCharacter(";", 0);

   string rawLevels[];

   int totalSplit = StringSplit(InpTargetLevels, u_sep, rawLevels);

   if(totalSplit <= 0)

     {

      Print("Error: No se especificaron niveles válidos en InpTargetLevels.");

      return;

     }

   ArrayResize(targetLevels, totalSplit);

   int validLevelsCount = 0;

   for(int i = 0; i < totalSplit; i++)

     {

      string trimmed = rawLevels[i];

      StringTrimLeft(trimmed);

      StringTrimRight(trimmed);

      if(StringLen(trimmed) > 0)

        {

         double val = StringToDouble(trimmed);

         if(val == 0.0 && trimmed != "0" && trimmed != "0.0" && trimmed != "0,0")

           {

            continue;

           }

         targetLevels[validLevelsCount] = val;

         validLevelsCount++;

        }

     }

   if(validLevelsCount == 0)

     {

      Print("Error: No se pudieron interpretar los niveles de Fibonacci especificados.");

      return;

     }

   // 2. Obtener precios de mercado actuales

   double ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);

   double bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);

   if(ask <= 0 || bid <= 0)

     {

      Print("Error: No se pudieron obtener los precios de cotización actuales.");

      return;

     }

   // 3. Buscar objetos con el prefijo en el gráfico

   int totalObjects = ObjectsTotal(0, -1, -1);

   int ordersPlaced = 0;

   for(int i = 0; i < totalObjects; i++)

     {

      string objName = ObjectName(0, i, -1);

      // Verificar si el objeto coincide con el prefijo

      if(StringFind(objName, InpPrefix) == 0)

        {

         // Extraer el nivel numérico del objeto

         string levelStr = StringSubstr(objName, StringLen(InpPrefix));

         double objLevel = StringToDouble(levelStr);

         // Verificar si el nivel de la línea está en nuestra lista seleccionada

         if(!IsLevelSelected(objLevel, targetLevels, validLevelsCount))

            continue;

         double linePrice = ObjectGetDouble(0, objName, OBJPROP_PRICE);

         linePrice = NormalizeDouble(linePrice, _Digits);

         if(linePrice <= 0)

            continue;

         // Normalizar TP y SL si están configurados

         double tp = (InpTakeProfit > 0) ? NormalizeDouble(InpTakeProfit, _Digits) : 0.0;

         double sl = (InpStopLoss > 0)   ? NormalizeDouble(InpStopLoss, _Digits)   : 0.0;

         // 4. Determinar tipo de orden y enviar

         if(InpDirection == DIR_BUY)

           {

            if(linePrice < ask)

              {

               if(trade.BuyLimit(InpLotSize, linePrice, _Symbol, sl, tp, ORDER_TIME_GTC, 0, InpOrderComment))

                 {

                  PrintFormat("Buy Limit colocada en el nivel %.1f%% al precio %.*f", objLevel, _Digits, linePrice);

                  ordersPlaced++;

                 }

               else

                 {

                  PrintFormat("Error al colocar Buy Limit en %.1f%%: %s", objLevel, trade.ResultComment());

                 }

              }

            else if(linePrice > ask)

              {

               if(trade.BuyStop(InpLotSize, linePrice, _Symbol, sl, tp, ORDER_TIME_GTC, 0, InpOrderComment))

                 {

                  PrintFormat("Buy Stop colocada en el nivel %.1f%% al precio %.*f", objLevel, _Digits, linePrice);

                  ordersPlaced++;

                 }

               else

                 {

                  PrintFormat("Error al colocar Buy Stop en %.1f%%: %s", objLevel, trade.ResultComment());

                 }

              }

           }

         else // DIR_SELL

           {

            if(linePrice > bid)

              {

               if(trade.SellLimit(InpLotSize, linePrice, _Symbol, sl, tp, ORDER_TIME_GTC, 0, InpOrderComment))

                 {

                  PrintFormat("Sell Limit colocada en el nivel %.1f%% al precio %.*f", objLevel, _Digits, linePrice);

                  ordersPlaced++;

                 }

               else

                 {

                  PrintFormat("Error al colocar Sell Limit en %.1f%%: %s", objLevel, trade.ResultComment());

                 }

              }

            else if(linePrice < bid)

              {

               if(trade.SellStop(InpLotSize, linePrice, _Symbol, sl, tp, ORDER_TIME_GTC, 0, InpOrderComment))

                 {

                  PrintFormat("Sell Stop colocada en el nivel %.1f%% al precio %.*f", objLevel, _Digits, linePrice);

                  ordersPlaced++;

                 }

               else

                 {

                  PrintFormat("Error al colocar Sell Stop en %.1f%%: %s", objLevel, trade.ResultComment());

                 }

              }

           }

        }

     }

   PrintFormat("NIVELESFIBONACCI2.12 (v2.12): Proceso finalizado. Total de órdenes colocadas: %d", ordersPlaced);

  }

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

//| Función auxiliar para comprobar si un nivel pertenece a la lista |

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

bool IsLevelSelected(double level, const double &selectedLevels[], int count)

  {

   for(int i = 0; i < count; i++)

     {

      if(MathAbs(level - selectedLevels[i]) < 0.01)

         return true;

     }

   return false;

  }

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

//| Función auxiliar para borrar las órdenes pendientes por Magic   |

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

int DeletePendingOrders(CTrade &trade, ulong magic)

  {

   int deleted = 0;

   int totalOrders = OrdersTotal();

   // Recorremos las órdenes en orden inverso para evitar desajustes de índice

   for(int i = totalOrders - 1; i >= 0; i--)

     {

      ulong ticket = OrderGetTicket(i);

      if(ticket > 0)

        {

         if(OrderGetString(ORDER_SYMBOL) == _Symbol && OrderGetInteger(ORDER_MAGIC) == magic)

           {

            if(trade.OrderDelete(ticket))

               deleted++;

            else

               PrintFormat("Error al borrar la orden #%d: %s", ticket, trade.ResultComment());

           }

        }

     }

   return deleted;

  }

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