HalfTrend 半趋势马丁交易系统

#property copyright "XAUOF 指标工坊"
#property version   "1.00"
#property description "HalfTrend 信号 + 动态止损 + 小马丁加仓 + 移动止盈 + 可视化面板"

#include <Trade\Trade.mqh>

//+------------------------------------------------------------------+
//| 输入参数                                                          |
//+------------------------------------------------------------------+
input group "===== 指标设置 ====="
input string   InpIndicatorName    = "HalfTrend";  // 指标文件名（不含.ex5后缀）
input int      InpIndicatorAmplitude = 2;           // 指标参数：灵敏度
input int      InpIndicatorAtrPeriod = 100;         // 指标参数：ATR周期
input int      InpBuyBufferIndex   = 6;             // 买入箭头缓冲区序号（从0开始）
input int      InpSellBufferIndex  = 7;             // 卖出箭头缓冲区序号（从0开始）

input group "===== 基础设置 ====="
input double   InpLots             = 0.01;          // 首单手数
input int      InpMagicNumber      = 20261021;      // EA 魔术号（用于识别自己的订单）
input string   InpComment          = "HT_Martin";   // 订单备注

input group "===== 止损设置 ====="
input int      InpStopLookback     = 10;            // 计算止损用的K线根数（推荐10）
input int      InpStopBuffer       = 1000;          // 止损缓冲点数（在高低点基础上再留的余量）

input group "===== 加仓设置 ====="
input bool     InpEnableMartingale = true;          // 是否启用马丁加仓
input int      InpMartinLayers     = 3;             // 最大加仓层数（含首单共3单）
input double   InpMartinMultiplier = 1.2;           // 加仓手数倍数（每层手数 × 1.2）
input int      InpMartinDistance   = 600;           // 加仓距离（浮亏多少点后加仓）

input group "===== 移动止盈设置 ====="
input bool     InpEnableTrailing   = true;          // 是否启用移动止盈
input int      InpTrailingStart    = 300;           // 启动移动止盈的盈利点数（价格盈利超过此值后开始跟踪）
input int      InpTrailingStep     = 150;           // 移动止盈跟踪距离（止损与价格保持的距离）

input group "===== 风控设置 ====="
input int      InpMaxSpread        = 300;           // 最大允许点差（超过此值不开仓）
input int      InpMaxSlippage      = 50;            // 最大滑点（点数）

input group "===== 可视化面板 ====="
input bool     InpShowPanel        = true;          // 是否显示可视化面板
input int      InpPanelX           = 20;            // 面板X坐标（像素）
input int      InpPanelY           = 50;            // 面板Y坐标（像素）
input color    InpPanelColor       = clrWhite;      // 面板文字颜色
input int      InpPanelFontSize    = 9;             // 面板字体大小

//+------------------------------------------------------------------+
//| 全局变量                                                          |
//+------------------------------------------------------------------+
CTrade         g_trade;                             // 交易对象
int            g_indicatorHandle = INVALID_HANDLE;  // 指标句柄

// 持仓状态跟踪
struct PositionState
{
   bool     hasPosition;      // 是否有持仓
   int      direction;        // 0=无, 1=多, -1=空
   int      layers;           // 已开仓层数（1、2、3）
   double   firstPrice;       // 首单开仓价
   double   stopLoss;         // 当前止损价
   double   totalLots;        // 总手数
   double   highestPrice;     // 多单：持仓后的最高价；用于移动止盈
   double   lowestPrice;      // 空单：持仓后的最低价；用于移动止盈
   bool     layerAdded[10];   // 每层是否已加仓（防止重复加仓）
};
PositionState g_position;

// 每日统计
struct DailyStats
{
   datetime lastResetDate;    // 上次重置日期
   int      todayOrders;      // 当日开单数
   double   todayProfit;      // 当日盈亏（金额）
   double   maxDrawdown;      // 最大回撤
};
DailyStats g_stats;

datetime g_lastSignalTime = 0;  // 上次信号时间（防止同一根K线重复开仓）
string   g_panelPrefix = "HTPanel_"; // 面板对象名前缀

//+------------------------------------------------------------------+
//| 初始化                                                            |
//+------------------------------------------------------------------+
int OnInit()
{
   //--- 参数校验
   if(InpLots <= 0)
   {
      Print("[错误] 首单手数必须大于 0");
      return INIT_PARAMETERS_INCORRECT;
   }
   if(InpStopLookback < 1)
   {
      Print("[错误] 止损回溯K线数必须大于等于 1");
      return INIT_PARAMETERS_INCORRECT;
   }
   if(InpMartinLayers < 1 || InpMartinLayers > 10)
   {
      Print("[错误] 加仓层数必须在 1-10 之间");
      return INIT_PARAMETERS_INCORRECT;
   }
   if(InpMartinMultiplier < 1.0)
   {
      Print("[错误] 加仓倍数必须大于等于 1.0");
      return INIT_PARAMETERS_INCORRECT;
   }

   //--- 设置 CTrade
   g_trade.SetExpertMagicNumber(InpMagicNumber);
   g_trade.SetDeviationInPoints(InpMaxSlippage);
   g_trade.SetTypeFilling(ORDER_FILLING_FOK);
   if(!g_trade.SetTypeFillingBySymbol(_Symbol))
      g_trade.SetTypeFilling(ORDER_FILLING_IOC);

   //--- 创建指标句柄
   g_indicatorHandle = iCustom(_Symbol, PERIOD_CURRENT, InpIndicatorName,
                                InpIndicatorAmplitude,
                                InpIndicatorAtrPeriod,
                                true,   // InpShowBands
                                true,   // InpShowArrows
                                false,  // InpAlertsOn
                                false, false, false, false);
   if(g_indicatorHandle == INVALID_HANDLE)
   {
      Print("[错误] 无法创建指标句柄，请确认指标文件名: ", InpIndicatorName, ".ex5，错误代码 ", GetLastError());
      return INIT_FAILED;
   }

   //--- 初始化持仓状态和统计
   ResetPositionState();
   ResetDailyStats();

   //--- 创建可视化面板
   if(InpShowPanel)
      CreatePanel();

   //--- 扫描现有持仓，恢复状态（断线重启时）
   RestorePositionState();

   //--- 打印所有参数到日志
   Print("========== HalfTrend 马丁 EA 启动 ==========");
   Print("[参数] 指标名称: ", InpIndicatorName, "，买入缓冲区: ", InpBuyBufferIndex, "，卖出缓冲区: ", InpSellBufferIndex);
   Print("[参数] 首单手数: ", InpLots);
   Print("[参数] 魔术号: ", InpMagicNumber);
   Print("[参数] 止损回溯K线: ", InpStopLookback, " 根，缓冲点数: ", InpStopBuffer);
   Print("[参数] 马丁加仓: ", (InpEnableMartingale ? "启用" : "禁用"), "，最大层数: ", InpMartinLayers, "，倍数: ", InpMartinMultiplier, "，距离: ", InpMartinDistance, " 点");
   Print("[参数] 移动止盈: ", (InpEnableTrailing ? "启用" : "禁用"), "，启动: ", InpTrailingStart, " 点，跟踪: ", InpTrailingStep, " 点");
   Print("[参数] 最大点差: ", InpMaxSpread, " 点，最大滑点: ", InpMaxSlippage, " 点");
   Print("============================================");

   return INIT_SUCCEEDED;
}

//+------------------------------------------------------------------+
//| 卸载                                                              |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
   if(g_indicatorHandle != INVALID_HANDLE)
      IndicatorRelease(g_indicatorHandle);

   if(InpShowPanel)
      DeletePanel();

   Print("[卸载] HalfTrend 马丁 EA 已停止，原因代码: ", reason);
}

//+------------------------------------------------------------------+
//| 主循环 - 修复：加仓检查移到这里，每个 Tick 都执行                 |
//+------------------------------------------------------------------+
void OnTick()
{
   //--- 检查是否需要重置每日统计（跨天）
   CheckDailyReset();

   //--- 更新当前持仓状态
   UpdatePositionState();

   //--- 持续监控：移动止盈
   if(InpEnableTrailing && g_position.hasPosition)
      ManageTrailingStop();

   //--- 持续监控：马丁加仓（关键修复：每个 Tick 都检查）
   if(InpEnableMartingale && g_position.hasPosition && g_position.layers < InpMartinLayers)
      CheckAndAddPosition();

   //--- 检查新信号
   int signal = GetSignal();

   if(signal == 1) // 买入信号
   {
      HandleBuySignal();
   }
   else if(signal == -1) // 卖出信号
   {
      HandleSellSignal();
   }

   //--- 更新可视化面板
   if(InpShowPanel)
      UpdatePanel();
}

//+------------------------------------------------------------------+
//| 获取指标信号                                                      |
//| 返回：1=买入箭头, -1=卖出箭头, 0=无信号                           |
//+------------------------------------------------------------------+
int GetSignal()
{
   if(BarsCalculated(g_indicatorHandle) < 2)
      return 0;

   double arrUp[2], arrDn[2];
   if(CopyBuffer(g_indicatorHandle, InpBuyBufferIndex, 0, 2, arrUp) < 2) return 0;
   if(CopyBuffer(g_indicatorHandle, InpSellBufferIndex, 0, 2, arrDn) < 2) return 0;

   //--- 读取倒数第二根已收盘 K 线的箭头（索引 0）
   datetime barTime = iTime(_Symbol, PERIOD_CURRENT, 1);
   
   if(arrUp[0] != EMPTY_VALUE && arrUp[0] > 0 && g_lastSignalTime != barTime)
   {
      g_lastSignalTime = barTime;
      return 1;
   }
   if(arrDn[0] != EMPTY_VALUE && arrDn[0] > 0 && g_lastSignalTime != barTime)
   {
      g_lastSignalTime = barTime;
      return -1;
   }

   return 0;
}

//+------------------------------------------------------------------+
//| 处理买入信号                                                      |
//+------------------------------------------------------------------+
void HandleBuySignal()
{
   //--- 如果当前有空单，先全部平掉
   if(g_position.direction == -1)
   {
      Print("[信号] 检测到买入信号，平掉所有空单");
      CloseAllPositions();
      ResetPositionState();
   }

   //--- 如果已有多单，不重复开仓（加仓由 CheckAndAddPosition 负责）
   if(g_position.direction == 1)
   {
      Print("[跳过] 已有多单，等待加仓逻辑触发");
      return;
   }

   //--- 无持仓，开首单
   OpenFirstPosition(1);
}

//+------------------------------------------------------------------+
//| 处理卖出信号                                                      |
//+------------------------------------------------------------------+
void HandleSellSignal()
{
   //--- 如果当前有多单，先全部平掉
   if(g_position.direction == 1)
   {
      Print("[信号] 检测到卖出信号，平掉所有多单");
      CloseAllPositions();
      ResetPositionState();
   }

   //--- 如果已有空单，不重复开仓
   if(g_position.direction == -1)
   {
      Print("[跳过] 已有空单，等待加仓逻辑触发");
      return;
   }

   //--- 无持仓，开首单
   OpenFirstPosition(-1);
}

//+------------------------------------------------------------------+
//| 开首单                                                            |
//+------------------------------------------------------------------+
void OpenFirstPosition(int direction)
{
   //--- 检查点差
   double spread = SymbolInfoInteger(_Symbol, SYMBOL_SPREAD);
   if(spread > InpMaxSpread)
   {
      Print("[跳过] 当前点差 ", (int)spread, " 点，超过限制 ", InpMaxSpread, " 点");
      return;
   }

   //--- 检查交易是否允许
   if(!SymbolInfoInteger(_Symbol, SYMBOL_TRADE_MODE))
   {
      Print("[跳过] 交易未启用");
      return;
   }

   //--- 规整手数
   double lots = NormalizeLots(InpLots);
   if(lots <= 0)
   {
      Print("[错误] 手数规整后为 0，无法开仓");
      return;
   }

   //--- 计算止损价
   double sl = CalculateStopLoss(direction);
   if(sl <= 0)
   {
      Print("[错误] 止损价计算失败");
      return;
   }

   //--- 获取当前价格
   double price = (direction == 1) ? SymbolInfoDouble(_Symbol, SYMBOL_ASK) : SymbolInfoDouble(_Symbol, SYMBOL_BID);

   //--- 检查止损距离是否满足最小要求
   int stopsLevel = (int)SymbolInfoInteger(_Symbol, SYMBOL_TRADE_STOPS_LEVEL);
   double minDistance = stopsLevel * _Point;
   if(MathAbs(price - sl) < minDistance)
   {
      Print("[警告] 止损距离 ", (int)(MathAbs(price - sl) / _Point), " 点小于最小距离 ", stopsLevel, " 点，调整止损");
      if(direction == 1)
         sl = price - minDistance - 10 * _Point;
      else
         sl = price + minDistance + 10 * _Point;
   }

   //--- 下单
   bool result = false;
   if(direction == 1)
      result = g_trade.Buy(lots, _Symbol, 0, sl, 0, InpComment);
   else
      result = g_trade.Sell(lots, _Symbol, 0, sl, 0, InpComment);

   if(result)
   {
      g_position.hasPosition = true;
      g_position.direction = direction;
      g_position.layers = 1;
      g_position.firstPrice = price;
      g_position.stopLoss = sl;
      g_position.totalLots = lots;
      g_position.highestPrice = price;
      g_position.lowestPrice = price;
      ArrayInitialize(g_position.layerAdded, false);
      g_position.layerAdded[0] = true;

      g_stats.todayOrders++;

      Print("[开仓] ", (direction == 1 ? "做多" : "做空"), " ", lots, " 手，价格: ", price,
            "，止损: ", sl, "，止损距离: ", (int)(MathAbs(price - sl) / _Point), " 点");
   }
   else
   {
      Print("[失败] 开仓失败，错误代码: ", g_trade.ResultRetcode(), "，错误描述: ", g_trade.ResultRetcodeDescription());
   }
}

//+------------------------------------------------------------------+
//| 检查并加仓 - 修复：移除 direction 参数，直接读取 g_position       |
//+------------------------------------------------------------------+
void CheckAndAddPosition()
{
   if(!g_position.hasPosition)
      return;

   int direction = g_position.direction;

   //--- 计算当前浮动盈亏（点数）
   double currentPrice = (direction == 1) ? SymbolInfoDouble(_Symbol, SYMBOL_BID) : SymbolInfoDouble(_Symbol, SYMBOL_ASK);
   double floatingPips = 0;
   if(direction == 1)
      floatingPips = (currentPrice - g_position.firstPrice) / _Point;
   else
      floatingPips = (g_position.firstPrice - currentPrice) / _Point;

   //--- 计算应该加到第几层
   int targetLayer = 1;
   double lossThreshold = -InpMartinDistance;
   while(targetLayer < InpMartinLayers && floatingPips < lossThreshold)
   {
      targetLayer++;
      lossThreshold -= InpMartinDistance;
   }

   //--- 如果应加的层还没加过
   if(targetLayer > g_position.layers && !g_position.layerAdded[targetLayer - 1])
   {
      //--- 检查点差
      double spread = SymbolInfoInteger(_Symbol, SYMBOL_SPREAD);
      if(spread > InpMaxSpread)
      {
         Print("[跳过] 加仓：当前点差 ", (int)spread, " 点，超过限制");
         return;
      }

      //--- 计算加仓手数
      double newLots = InpLots;
      for(int i = 1; i < targetLayer; i++)
         newLots *= InpMartinMultiplier;
      newLots = NormalizeLots(newLots);

      if(newLots <= 0)
      {
         Print("[错误] 加仓手数规整后为 0");
         return;
      }

      //--- 加仓单使用相同的止损
      bool result = false;
      if(direction == 1)
         result = g_trade.Buy(newLots, _Symbol, 0, g_position.stopLoss, 0, InpComment);
      else
         result = g_trade.Sell(newLots, _Symbol, 0, g_position.stopLoss, 0, InpComment);

      if(result)
      {
         g_position.layers = targetLayer;
         g_position.totalLots += newLots;
         g_position.layerAdded[targetLayer - 1] = true;
         g_stats.todayOrders++;

         Print("[加仓] 第 ", targetLayer, " 层，", (direction == 1 ? "做多" : "做空"), " ", newLots,
               " 手，浮亏: ", (int)floatingPips, " 点，总手数: ", g_position.totalLots);
      }
      else
      {
         Print("[失败] 加仓失败，错误代码: ", g_trade.ResultRetcode(), "，描述: ", g_trade.ResultRetcodeDescription());
      }
   }
}

//+------------------------------------------------------------------+
//| 管理移动止盈                                                      |
//+------------------------------------------------------------------+
void ManageTrailingStop()
{
   double currentPrice = (g_position.direction == 1) ? SymbolInfoDouble(_Symbol, SYMBOL_BID) : SymbolInfoDouble(_Symbol, SYMBOL_ASK);

   if(g_position.direction == 1) // 多单
   {
      //--- 更新最高价
      if(currentPrice > g_position.highestPrice)
         g_position.highestPrice = currentPrice;

      //--- 盈利超过启动距离
      double profit = (currentPrice - g_position.firstPrice) / _Point;
      if(profit > InpTrailingStart)
      {
         double newSL = currentPrice - InpTrailingStep * _Point;
         //--- 止损只能上移
         if(newSL > g_position.stopLoss + _Point)
         {
            ModifyAllPositionsSL(newSL);
         }
      }
   }
   else if(g_position.direction == -1) // 空单
   {
      //--- 更新最低价
      if(currentPrice < g_position.lowestPrice)
         g_position.lowestPrice = currentPrice;

      //--- 盈利超过启动距离
      double profit = (g_position.firstPrice - currentPrice) / _Point;
      if(profit > InpTrailingStart)
      {
         double newSL = currentPrice + InpTrailingStep * _Point;
         //--- 止损只能下移
         if(newSL < g_position.stopLoss - _Point)
         {
            ModifyAllPositionsSL(newSL);
         }
      }
   }
}

//+------------------------------------------------------------------+
//| 修改所有同方向持仓的止损                                          |
//+------------------------------------------------------------------+
void ModifyAllPositionsSL(double newSL)
{
   int modifiedCount = 0;
   for(int i = PositionsTotal() - 1; i >= 0; i--)
   {
      ulong ticket = PositionGetTicket(i);
      if(ticket == 0) continue;
      if(PositionGetString(POSITION_SYMBOL) != _Symbol) continue;
      if(PositionGetInteger(POSITION_MAGIC) != InpMagicNumber) continue;

      double currentSL = PositionGetDouble(POSITION_SL);
      double tp = PositionGetDouble(POSITION_TP);

      if(MathAbs(newSL - currentSL) > _Point)
      {
         if(g_trade.PositionModify(ticket, newSL, tp))
            modifiedCount++;
      }
   }

   if(modifiedCount > 0)
   {
      Print("[移动止盈] 已修改 ", modifiedCount, " 个订单，新止损: ", newSL);
      g_position.stopLoss = newSL;
   }
}

//+------------------------------------------------------------------+
//| 计算止损价（近N根K线高低点 ± 缓冲）                               |
//+------------------------------------------------------------------+
double CalculateStopLoss(int direction)
{
   double highArray[], lowArray[];
   ArraySetAsSeries(highArray, true);
   ArraySetAsSeries(lowArray, true);

   int copied = CopyHigh(_Symbol, PERIOD_CURRENT, 0, InpStopLookback + 1, highArray);
   if(copied < InpStopLookback + 1) return 0;
   copied = CopyLow(_Symbol, PERIOD_CURRENT, 0, InpStopLookback + 1, lowArray);
   if(copied < InpStopLookback + 1) return 0;

   double highest = highArray[ArrayMaximum(highArray, 0, InpStopLookback)];
   double lowest  = lowArray[ArrayMinimum(lowArray, 0, InpStopLookback)];

   double sl = 0;
   if(direction == 1)
      sl = lowest - InpStopBuffer * _Point;
   else
      sl = highest + InpStopBuffer * _Point;

   return NormalizeDouble(sl, _Digits);
}

//+------------------------------------------------------------------+
//| 规整手数                                                          |
//+------------------------------------------------------------------+
double NormalizeLots(double lots)
{
   double minLot  = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN);
   double maxLot  = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MAX);
   double stepLot = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_STEP);

   if(lots < minLot) lots = minLot;
   if(lots > maxLot) lots = maxLot;

   lots = MathFloor(lots / stepLot) * stepLot;
   return NormalizeDouble(lots, 2);
}

//+------------------------------------------------------------------+
//| 平掉所有本 EA 的持仓                                              |
//+------------------------------------------------------------------+
void CloseAllPositions()
{
   for(int i = PositionsTotal() - 1; i >= 0; i--)
   {
      ulong ticket = PositionGetTicket(i);
      if(ticket == 0) continue;
      if(PositionGetString(POSITION_SYMBOL) != _Symbol) continue;
      if(PositionGetInteger(POSITION_MAGIC) != InpMagicNumber) continue;

      double profit = PositionGetDouble(POSITION_PROFIT);
      g_stats.todayProfit += profit;

      if(g_trade.PositionClose(ticket))
         Print("[平仓] 订单 ", ticket, " 已平仓，盈亏: ", profit);
      else
         Print("[失败] 平仓订单 ", ticket, " 失败，错误代码: ", g_trade.ResultRetcode());
   }
}

//+------------------------------------------------------------------+
//| 更新持仓状态 - 修复：恢复 firstPrice                              |
//+------------------------------------------------------------------+
void UpdatePositionState()
{
   int buyCount = 0, sellCount = 0;
   double totalBuyLots = 0, totalSellLots = 0;
   double firstBuyPrice = 0, firstSellPrice = 0;
   double buySL = 0, sellSL = 0;

   for(int i = 0; i < PositionsTotal(); i++)
   {
      ulong ticket = PositionGetTicket(i);
      if(ticket == 0) continue;
      if(PositionGetString(POSITION_SYMBOL) != _Symbol) continue;
      if(PositionGetInteger(POSITION_MAGIC) != InpMagicNumber) continue;

      long type = PositionGetInteger(POSITION_TYPE);
      double lots = PositionGetDouble(POSITION_VOLUME);
      double openPrice = PositionGetDouble(POSITION_PRICE_OPEN);
      double sl = PositionGetDouble(POSITION_SL);
      datetime openTime = (datetime)PositionGetInteger(POSITION_TIME);

      if(type == POSITION_TYPE_BUY)
      {
         buyCount++;
         totalBuyLots += lots;
         //--- 首单价格：取最早开仓的那一单
         if(firstBuyPrice == 0 || openTime < (datetime)PositionGetInteger(POSITION_TIME))
         {
            firstBuyPrice = openPrice;
            buySL = sl;
         }
      }
      else if(type == POSITION_TYPE_SELL)
      {
         sellCount++;
         totalSellLots += lots;
         if(firstSellPrice == 0 || openTime < (datetime)PositionGetInteger(POSITION_TIME))
         {
            firstSellPrice = openPrice;
            sellSL = sl;
         }
      }
   }

   //--- 如果没有持仓，重置状态
   if(buyCount == 0 && sellCount == 0)
   {
      if(g_position.hasPosition)
      {
         Print("[状态] 所有持仓已平仓");
         ResetPositionState();
      }
      return;
   }

   //--- 更新状态
   if(buyCount > 0)
   {
      g_position.hasPosition = true;
      g_position.direction = 1;
      g_position.layers = buyCount;
      g_position.totalLots = totalBuyLots;
      //--- 如果 firstPrice 还是0（说明刚启动EA），就从持仓恢复
      if(g_position.firstPrice == 0)
         g_position.firstPrice = firstBuyPrice;
      if(g_position.stopLoss == 0)
         g_position.stopLoss = buySL;
   }
   else if(sellCount > 0)
   {
      g_position.hasPosition = true;
      g_position.direction = -1;
      g_position.layers = sellCount;
      g_position.totalLots = totalSellLots;
      if(g_position.firstPrice == 0)
         g_position.firstPrice = firstSellPrice;
      if(g_position.stopLoss == 0)
         g_position.stopLoss = sellSL;
   }
}

//+------------------------------------------------------------------+
//| 恢复持仓状态（断线重启时）                                        |
//+------------------------------------------------------------------+
void RestorePositionState()
{
   UpdatePositionState();

   if(g_position.hasPosition)
   {
      Print("[恢复] 检测到现有持仓：方向=", (g_position.direction == 1 ? "多" : "空"),
            "，层数=", g_position.layers, "，首单价=", g_position.firstPrice,
            "，止损=", g_position.stopLoss, "，总手数=", g_position.totalLots);
      
      //--- 标记已有的层数为"已加仓"
      for(int i = 0; i < g_position.layers; i++)
         g_position.layerAdded[i] = true;
   }
}

//+------------------------------------------------------------------+
//| 重置持仓状态                                                      |
//+------------------------------------------------------------------+
void ResetPositionState()
{
   g_position.hasPosition = false;
   g_position.direction = 0;
   g_position.layers = 0;
   g_position.firstPrice = 0;
   g_position.stopLoss = 0;
   g_position.totalLots = 0;
   g_position.highestPrice = 0;
   g_position.lowestPrice = 0;
   ArrayInitialize(g_position.layerAdded, false);
}

//+------------------------------------------------------------------+
//| 检查每日重置                                                      |
//+------------------------------------------------------------------+
void CheckDailyReset()
{
   MqlDateTime dt;
   TimeToStruct(TimeCurrent(), dt);
   datetime today = StringToTime(IntegerToString(dt.year) + "." + IntegerToString(dt.mon) + "." + IntegerToString(dt.day));

   if(g_stats.lastResetDate != today)
   {
      if(g_stats.lastResetDate != 0)
         Print("[统计] 昨日盈亏: ", g_stats.todayProfit, " USD，开单数: ", g_stats.todayOrders);
      
      ResetDailyStats();
      g_stats.lastResetDate = today;
   }
}

//+------------------------------------------------------------------+
//| 重置每日统计                                                      |
//+------------------------------------------------------------------+
void ResetDailyStats()
{
   MqlDateTime dt;
   TimeToStruct(TimeCurrent(), dt);
   g_stats.lastResetDate = StringToTime(IntegerToString(dt.year) + "." + IntegerToString(dt.mon) + "." + IntegerToString(dt.day));
   g_stats.todayOrders = 0;
   g_stats.todayProfit = 0;
   g_stats.maxDrawdown = 0;
}

//+------------------------------------------------------------------+
//| 创建可视化面板                                                    |
//+------------------------------------------------------------------+
void CreatePanel()
{
   string labels[] = {"标题", "状态", "层数", "手数", "浮盈", "今日盈亏", "今日单数"};
   int count = ArraySize(labels);

   for(int i = 0; i < count; i++)
   {
      string objName = g_panelPrefix + IntegerToString(i);
      if(ObjectCreate(0, objName, OBJ_LABEL, 0, 0, 0))
      {
         ObjectSetInteger(0, objName, OBJPROP_CORNER, CORNER_LEFT_UPPER);
         ObjectSetInteger(0, objName, OBJPROP_XDISTANCE, InpPanelX);
         ObjectSetInteger(0, objName, OBJPROP_YDISTANCE, InpPanelY + i * (InpPanelFontSize + 5));
         ObjectSetInteger(0, objName, OBJPROP_COLOR, InpPanelColor);
         ObjectSetInteger(0, objName, OBJPROP_FONTSIZE, InpPanelFontSize);
         ObjectSetString(0, objName, OBJPROP_FONT, "Arial");
         ObjectSetString(0, objName, OBJPROP_TEXT, labels[i]);
      }
   }
}

//+------------------------------------------------------------------+
//| 更新可视化面板                                                    |
//+------------------------------------------------------------------+
void UpdatePanel()
{
   string status = "无持仓";
   string layers = "-";
   string lots = "-";
   string floating = "-";
   
   if(g_position.hasPosition)
   {
      status = (g_position.direction == 1) ? "多单" : "空单";
      layers = IntegerToString(g_position.layers) + " / " + IntegerToString(InpMartinLayers);
      lots = DoubleToString(g_position.totalLots, 2);
      
      //--- 计算浮动盈亏
      double floatingProfit = 0;
      for(int i = 0; i < PositionsTotal(); i++)
      {
         ulong ticket = PositionGetTicket(i);
         if(ticket == 0) continue;
         if(PositionGetString(POSITION_SYMBOL) != _Symbol) continue;
         if(PositionGetInteger(POSITION_MAGIC) != InpMagicNumber) continue;
         floatingProfit += PositionGetDouble(POSITION_PROFIT);
      }
      floating = DoubleToString(floatingProfit, 2) + " USD";
   }

   ObjectSetString(0, g_panelPrefix + "0", OBJPROP_TEXT, "=== HalfTrend 马丁 EA ===");
   ObjectSetString(0, g_panelPrefix + "1", OBJPROP_TEXT, "状态: " + status);
   ObjectSetString(0, g_panelPrefix + "2", OBJPROP_TEXT, "层数: " + layers);
   ObjectSetString(0, g_panelPrefix + "3", OBJPROP_TEXT, "手数: " + lots);
   ObjectSetString(0, g_panelPrefix + "4", OBJPROP_TEXT, "浮盈: " + floating);
   ObjectSetString(0, g_panelPrefix + "5", OBJPROP_TEXT, "今日盈亏: " + DoubleToString(g_stats.todayProfit, 2) + " USD");
   ObjectSetString(0, g_panelPrefix + "6", OBJPROP_TEXT, "今日开单: " + IntegerToString(g_stats.todayOrders) + " 次");
}

//+------------------------------------------------------------------+
//| 删除可视化面板                                                    |
//+------------------------------------------------------------------+
void DeletePanel()
{
   for(int i = 0; i < 10; i++)
   {
      string objName = g_panelPrefix + IntegerToString(i);
      ObjectDelete(0, objName);
   }
}
//+------------------------------------------------------------------+