#ifndef SLTP_MANAGER_MQH #define SLTP_MANAGER_MQH #include /// @brief 同一シンボル・同一マジックナンバーの建玉に対して、SLを段階的に引き上げる管理クラス。 /// @details 建値移動、アクティブトレーリング、TP進捗率ベースのSL固定をまとめて評価し、 /// 現在のSLより有利な候補だけを `CTrade::PositionModify` で反映する。 class CSLTPManager { private: ulong m_magic; string m_symbol; ulong m_deviation_points; CTrade m_trade; bool m_use_breakeven; double m_breakeven_trigger_pips; double m_breakeven_buffer_pips; bool m_use_elapsed_breakeven; double m_elapsed_breakeven_hours; double m_elapsed_breakeven_buffer_pips; bool m_use_active_trailing; double m_active_breakeven_pips; double m_active_stop_loss_offset_pips; double m_active_step_trigger_pips; double m_active_step_move_pips; bool m_use_tp_progress_stop; double m_tp_progress_trigger_percent; double m_tp_progress_sl_lock_percent; bool m_use_high_volatility_limit; public: /// @brief SL/TP管理クラスの初期状態を構築する。 /// @details デフォルトでは現在チャートのシンボルを対象にし、すべてのSL移動ロジックを無効化する。 CSLTPManager() { m_magic = 0; m_symbol = _Symbol; m_deviation_points = 10; m_use_breakeven = false; m_breakeven_trigger_pips = 0.0; m_breakeven_buffer_pips = 0.0; m_use_elapsed_breakeven = false; m_elapsed_breakeven_hours = 0.0; m_elapsed_breakeven_buffer_pips = 0.0; m_use_active_trailing = false; m_active_breakeven_pips = 0.0; m_active_stop_loss_offset_pips = 0.0; m_active_step_trigger_pips = 0.0; m_active_step_move_pips = 0.0; m_use_tp_progress_stop = false; m_tp_progress_trigger_percent = 0.0; m_tp_progress_sl_lock_percent = 0.0; m_use_high_volatility_limit = false; } /// @brief 管理対象ポジションのマジックナンバーを設定する。 /// @param magic 対象EAに割り当てられたマジックナンバー。 /// @details `CTrade` にも同じマジックナンバーを渡し、注文変更ログと実行元を揃える。 void SetMagicNumber(const ulong magic) { m_magic = magic; m_trade.SetExpertMagicNumber(m_magic); } /// @brief 管理対象のシンボルを設定する。 /// @param symbol `_Symbol` または任意の取引シンボル名。 void SetSymbol(const string symbol) { m_symbol = symbol; } /// @brief SL変更注文に使用する許容スリッページをポイント単位で設定する。 /// @param deviation_points `CTrade::SetDeviationInPoints` に渡すポイント数。 void SetDeviationInPoints(const ulong deviation_points) { m_deviation_points = deviation_points; m_trade.SetDeviationInPoints((int)m_deviation_points); } /// @brief 建値移動ロジックの有効化とバッファー幅を設定する。 /// @param use_breakeven true の場合、利益が閾値を超えた時にSLを建値付近へ移動する。 /// @param breakeven_trigger_pips 建値移動を開始する含み益のpips。 /// @param breakeven_buffer_pips 建値から利益方向へずらして固定するバッファーpips。 void SetBreakevenSettings(const bool use_breakeven, const double breakeven_trigger_pips, const double breakeven_buffer_pips) { m_use_breakeven = use_breakeven; m_breakeven_trigger_pips = breakeven_trigger_pips; m_breakeven_buffer_pips = breakeven_buffer_pips; } /// @brief 保有時間ベースの建値移動ロジックを設定する。 /// @param use_elapsed_breakeven true の場合、保有時間と建値超過を条件にSLを建値付近へ移動する。 /// @param elapsed_breakeven_hours 建値移動を許可するまでの保有時間。小数指定も可能。 /// @param elapsed_breakeven_buffer_pips 建値から利益方向へずらして固定するバッファーpips。 void SetElapsedBreakevenSettings(const bool use_elapsed_breakeven, const double elapsed_breakeven_hours, const double elapsed_breakeven_buffer_pips) { m_use_elapsed_breakeven = use_elapsed_breakeven; m_elapsed_breakeven_hours = elapsed_breakeven_hours; m_elapsed_breakeven_buffer_pips = elapsed_breakeven_buffer_pips; } /// @brief アクティブトレーリングロジックの有効化と段階移動幅を設定する。 /// @param use_active_trailing true の場合、利益進捗に応じてSLを段階的に更新する。 /// @param active_breakeven_pips トレーリングを開始する含み益のpips。 /// @param active_stop_loss_offset_pips 開始時点で建値から固定する初期pips。 /// @param active_step_trigger_pips SLを次段階へ進めるために必要な追加利益pips。 /// @param active_step_move_pips 1段階ごとにSLを利益方向へ動かすpips。 void SetActiveTrailingSettings(const bool use_active_trailing, const double active_breakeven_pips, const double active_stop_loss_offset_pips, const double active_step_trigger_pips, const double active_step_move_pips) { m_use_active_trailing = use_active_trailing; m_active_breakeven_pips = active_breakeven_pips; m_active_stop_loss_offset_pips = active_stop_loss_offset_pips; m_active_step_trigger_pips = active_step_trigger_pips; m_active_step_move_pips = active_step_move_pips; } /// @brief TP到達進捗率を基準にSLを固定するロジックを設定する。 /// @param use_tp_progress_stop true の場合、現在価格がTP距離の一定割合へ到達した時にSLを固定する。 /// @param tp_progress_trigger_percent SL固定を開始するTP進捗率。範囲は `(0, 100]`。 /// @param tp_progress_sl_lock_percent TP距離のうちSLで固定する割合。範囲は `[0, 100]`。 void SetTpProgressStopSettings(const bool use_tp_progress_stop, const double tp_progress_trigger_percent, const double tp_progress_sl_lock_percent) { m_use_tp_progress_stop = use_tp_progress_stop; m_tp_progress_trigger_percent = tp_progress_trigger_percent; m_tp_progress_sl_lock_percent = tp_progress_sl_lock_percent; } /// @brief 高ボラティリティ時のSL引き締めロジックを有効化/無効化する。 /// @param use_high_volatility_limit true の場合、HighVolatilityLimit() 呼び出し時に急変幅ベースでSLを更新する。 void SetHighVolatilityLimitSettings(const bool use_high_volatility_limit) { m_use_high_volatility_limit = use_high_volatility_limit; } /// @brief 設定値とシンボル状態が実行可能か検証する。 /// @return すべての設定が有効で、シンボル選択とpips換算が可能な場合は true。 /// @details 建値移動とアクティブトレーリングの同時有効化など、矛盾する設定を事前に弾く。 bool ValidateSettings() { if (m_symbol == "") { Print("SLTPManager settings error: symbol is empty."); return false; } if (!SymbolSelect(m_symbol, true)) { Print("SLTPManager settings error: failed to select symbol=", m_symbol, " err=", GetLastError()); return false; } if (m_use_breakeven && m_use_active_trailing) { Print("SLTPManager settings error: use_breakeven and use_active_trailing cannot both be true."); return false; } if (m_use_breakeven) { if (m_breakeven_trigger_pips < 0.0 || m_breakeven_buffer_pips < 0.0) { Print("SLTPManager settings error: breakeven trigger and buffer pips must be non-negative."); return false; } } if (m_use_elapsed_breakeven) { if (m_elapsed_breakeven_hours < 0.0 || m_elapsed_breakeven_buffer_pips < 0.0) { Print("SLTPManager settings error: elapsed breakeven hours and buffer pips must be non-negative."); return false; } } if (m_use_active_trailing) { if (m_active_breakeven_pips < 0.0 || m_active_stop_loss_offset_pips < 0.0 || m_active_step_trigger_pips <= 0.0 || m_active_step_move_pips <= 0.0) { Print("SLTPManager settings error: active trailing requires non-negative breakeven/offset and positive step values."); return false; } } if (m_use_tp_progress_stop) { if (m_tp_progress_trigger_percent <= 0.0 || m_tp_progress_trigger_percent > 100.0 || m_tp_progress_sl_lock_percent < 0.0 || m_tp_progress_sl_lock_percent > 100.0) { Print("SLTPManager settings error: TP progress percentages must be trigger=(0,100], lock=[0,100]."); return false; } } if (PipSize() <= 0.0) return false; return true; } /// @brief 現在保有中の対象ポジションを走査し、必要に応じてSLを更新する。 /// @details 対象は `m_magic` と `m_symbol` が一致するポジションのみ。複数のSL候補がある場合、 /// BUYでは最も高いSL、SELLでは最も低いSLを採用し、既存SLより不利な変更は行わない。 void ManagePositions() { const double pip_size = PipSize(); if (pip_size <= 0.0) return; MqlTick tick; if (!SymbolInfoTick(m_symbol, tick)) { Print("SLTPManager tick read failed: symbol=", m_symbol, " err=", GetLastError()); return; } const int digits = (int)SymbolInfoInteger(m_symbol, SYMBOL_DIGITS); const datetime current_time = tick.time; const int pos_total = PositionsTotal(); for (int i = pos_total - 1; i >= 0; --i) { const ulong ticket = PositionGetTicket(i); if (!PositionSelectByTicket(ticket)) continue; if (!IsTargetPosition()) continue; const ENUM_POSITION_TYPE type = (ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE); if (type != POSITION_TYPE_BUY && type != POSITION_TYPE_SELL) continue; const double open_price = PositionGetDouble(POSITION_PRICE_OPEN); const double current_sl = PositionGetDouble(POSITION_SL); const double current_tp = PositionGetDouble(POSITION_TP); const double market_price = (type == POSITION_TYPE_BUY) ? tick.bid : tick.ask; const double profit_pips = GetProfitPips(type, open_price, market_price, pip_size); const datetime open_time = (datetime)PositionGetInteger(POSITION_TIME); bool has_candidate = false; double candidate_sl = 0.0; double sl_value = 0.0; if (CalcBreakevenSL(type, open_price, profit_pips, pip_size, digits, sl_value)) UpdateBestCandidate(type, sl_value, has_candidate, candidate_sl); if (CalcElapsedBreakevenSL(type, open_price, profit_pips, open_time, current_time, pip_size, digits, sl_value)) UpdateBestCandidate(type, sl_value, has_candidate, candidate_sl); if (CalcActiveTrailingSL(type, open_price, profit_pips, pip_size, digits, sl_value)) UpdateBestCandidate(type, sl_value, has_candidate, candidate_sl); if (CalcTpProgressSL(type, open_price, current_tp, market_price, digits, sl_value)) UpdateBestCandidate(type, sl_value, has_candidate, candidate_sl); if (!has_candidate) continue; candidate_sl = NormalizeDouble(candidate_sl, digits); if (!IsBetterStopLoss(type, candidate_sl, current_sl)) continue; if (!IsStopDistanceAllowed(type, market_price, candidate_sl)) continue; ModifyStopLoss(ticket, candidate_sl, current_tp); } } /// @brief 短時間で大きな価格変動が発生した場合にSLを引き締める。 /// @details M1/M3/M5/M10/M15 の始値から現在Bidまでの変動幅を見て、 /// しきい値を超えた場合だけ利益方向へSL候補を作る。ManagePositions() とは独立して呼び出す。 void HighVolatilityLimit() { if (!m_use_high_volatility_limit) return; const double pip_size = PipSize(); if (pip_size <= 0.0) return; MqlTick tick; if (!SymbolInfoTick(m_symbol, tick)) { Print("SLTPManager tick read failed: symbol=", m_symbol, " err=", GetLastError()); return; } const int digits = (int)SymbolInfoInteger(m_symbol, SYMBOL_DIGITS); const double open_m1 = iOpen(m_symbol, PERIOD_M1, 0); const double open_m3 = iOpen(m_symbol, PERIOD_M3, 0); const double open_m5 = iOpen(m_symbol, PERIOD_M5, 0); const double open_m10 = iOpen(m_symbol, PERIOD_M10, 0); const double open_m15 = iOpen(m_symbol, PERIOD_M15, 0); const int pos_total = PositionsTotal(); for (int i = pos_total - 1; i >= 0; --i) { const ulong ticket = PositionGetTicket(i); if (!PositionSelectByTicket(ticket)) continue; if (!IsTargetPosition()) continue; const ENUM_POSITION_TYPE type = (ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE); if (type != POSITION_TYPE_BUY && type != POSITION_TYPE_SELL) continue; double candidate_sl = 0.0; const double evaluation_price = (type == POSITION_TYPE_BUY) ? tick.bid : tick.ask; if (!CalcHighVolatilitySL(type, evaluation_price, open_m1, open_m3, open_m5, open_m10, open_m15, pip_size, digits, candidate_sl)) { continue; } const double current_sl = PositionGetDouble(POSITION_SL); const double current_tp = PositionGetDouble(POSITION_TP); const double market_price = (type == POSITION_TYPE_BUY) ? tick.bid : tick.ask; if (!IsBetterStopLoss(type, candidate_sl, current_sl)) continue; if (!IsStopDistanceAllowed(type, market_price, candidate_sl)) continue; ModifyStopLoss(ticket, candidate_sl, current_tp); } } private: /// @brief 現在選択中のポジションが管理対象か判定する。 /// @return マジックナンバーとシンボルが一致する場合は true。 bool IsTargetPosition() { if ((ulong)PositionGetInteger(POSITION_MAGIC) != m_magic) return false; if (PositionGetString(POSITION_SYMBOL) != m_symbol) return false; return true; } /// @brief 対象シンボルの1 pip相当の価格幅を取得する。 /// @return 1 pip の価格幅。取得できない場合は 0.0。 /// @details GOLD/XAUUSD は 0.1、2/3桁は0.01、4/5桁は0.0001を1 pipとして扱う。 double PipSize() { string normalized_symbol = m_symbol; StringToUpper(normalized_symbol); if (StringFind(normalized_symbol, "XAUUSD") >= 0 || StringFind(normalized_symbol, "GOLD") >= 0) return 0.1; const int digits = (int)SymbolInfoInteger(m_symbol, SYMBOL_DIGITS); switch (digits) { case 2: case 3: return 0.01; case 4: case 5: return 0.0001; } Print("SLTPManager pip conversion error: unsupported symbol digits. symbol=", m_symbol, " digits=", digits); return 0.0; } /// @brief 現在価格から建値に対する含み益をpipsで計算する。 /// @param type ポジション種別。BUY/SELLで計算方向を切り替える。 /// @param open_price 建値。 /// @param market_price BUYはBid、SELLはAskを想定した現在価格。 /// @param pip_size `PipSize()` で取得した1 pipの価格幅。 /// @return 利益方向なら正、損失方向なら負のpips。 double GetProfitPips(const ENUM_POSITION_TYPE type, const double open_price, const double market_price, const double pip_size) { if (pip_size <= 0.0) return 0.0; if (type == POSITION_TYPE_BUY) return (market_price - open_price) / pip_size; return (open_price - market_price) / pip_size; } /// @brief 建値移動ロジックに基づくSL候補を計算する。 /// @param type ポジション種別。 /// @param open_price 建値。 /// @param profit_pips 現在の含み益pips。 /// @param pip_size 1 pipの価格幅。 /// @param digits 対象シンボルの小数桁数。 /// @param sl_value 計算に成功したSL候補の出力先。 /// @return 建値移動条件を満たし、SL候補を出力した場合は true。 /// @details BUYでは建値 + バッファー、SELLでは建値 - バッファーへSLを置き、 /// スプレッドや手数料分を考慮した利益保護ラインとして扱う。 bool CalcBreakevenSL(const ENUM_POSITION_TYPE type, const double open_price, const double profit_pips, const double pip_size, const int digits, double &sl_value) { if (!m_use_breakeven) return false; if (profit_pips < m_breakeven_trigger_pips) return false; if (type == POSITION_TYPE_BUY) sl_value = open_price + m_breakeven_buffer_pips * pip_size; else sl_value = open_price - m_breakeven_buffer_pips * pip_size; sl_value = NormalizeDouble(sl_value, digits); return true; } /// @brief 保有時間ベースの建値移動ロジックに基づくSL候補を計算する。 /// @param type ポジション種別。 /// @param open_price 建値。 /// @param profit_pips 現在の含み益pips。現在レートが建値を超えているかの判定に使う。 /// @param open_time ポジションの約定時刻。 /// @param current_time 評価時点のサーバー時刻。 /// @param pip_size 1 pipの価格幅。 /// @param digits 対象シンボルの小数桁数。 /// @param sl_value 計算に成功したSL候補の出力先。 /// @return 保有時間と建値超過条件を満たし、SL候補を出力した場合は true。 /// @details 通常ブレークイーブンとは独立した候補として評価し、長時間保有ポジションの損失化を防ぐ。 bool CalcElapsedBreakevenSL(const ENUM_POSITION_TYPE type, const double open_price, const double profit_pips, const datetime open_time, const datetime current_time, const double pip_size, const int digits, double &sl_value) { if (!m_use_elapsed_breakeven) return false; if (open_time <= 0 || current_time <= open_time) return false; if (profit_pips <= 0.0) return false; const double required_seconds = m_elapsed_breakeven_hours * 3600.0; const double held_seconds = (double)(current_time - open_time); if (held_seconds < required_seconds) return false; if (type == POSITION_TYPE_BUY) sl_value = open_price + m_elapsed_breakeven_buffer_pips * pip_size; else sl_value = open_price - m_elapsed_breakeven_buffer_pips * pip_size; sl_value = NormalizeDouble(sl_value, digits); return true; } /// @brief アクティブトレーリングロジックに基づくSL候補を計算する。 /// @param type ポジション種別。 /// @param open_price 建値。 /// @param profit_pips 現在の含み益pips。 /// @param pip_size 1 pipの価格幅。 /// @param digits 対象シンボルの小数桁数。 /// @param sl_value 計算に成功したSL候補の出力先。 /// @return トレーリング開始条件を満たし、SL候補を出力した場合は true。 /// @details 開始利益からの超過分をステップ数へ変換し、固定済み利益幅を段階的に増やす。 bool CalcActiveTrailingSL(const ENUM_POSITION_TYPE type, const double open_price, const double profit_pips, const double pip_size, const int digits, double &sl_value) { if (!m_use_active_trailing) return false; if (profit_pips < m_active_breakeven_pips) return false; int trail_steps = (int)MathFloor((profit_pips - m_active_breakeven_pips) / m_active_step_trigger_pips); if (trail_steps < 0) trail_steps = 0; const double locked_pips = m_active_stop_loss_offset_pips + trail_steps * m_active_step_move_pips; if (type == POSITION_TYPE_BUY) sl_value = open_price + locked_pips * pip_size; else sl_value = open_price - locked_pips * pip_size; sl_value = NormalizeDouble(sl_value, digits); return true; } /// @brief TP進捗率ベースのSL候補を計算する。 /// @param type ポジション種別。 /// @param open_price 建値。 /// @param current_tp 現在設定されているTP価格。未設定の場合は 0.0。 /// @param market_price BUYはBid、SELLはAskを想定した現在価格。 /// @param digits 対象シンボルの小数桁数。 /// @param sl_value 計算に成功したSL候補の出力先。 /// @return TP方向と進捗率が有効で、SL候補を出力した場合は true。 bool CalcTpProgressSL(const ENUM_POSITION_TYPE type, const double open_price, const double current_tp, const double market_price, const int digits, double &sl_value) { if (!m_use_tp_progress_stop) return false; if (current_tp == 0.0) return false; double tp_distance = 0.0; double progressed_distance = 0.0; if (type == POSITION_TYPE_BUY) { if (current_tp <= open_price) return false; tp_distance = current_tp - open_price; progressed_distance = market_price - open_price; sl_value = open_price + tp_distance * (m_tp_progress_sl_lock_percent / 100.0); } else { if (current_tp >= open_price) return false; tp_distance = open_price - current_tp; progressed_distance = open_price - market_price; sl_value = open_price - tp_distance * (m_tp_progress_sl_lock_percent / 100.0); } if (tp_distance <= 0.0) return false; const double progress_percent = (progressed_distance / tp_distance) * 100.0; if (progress_percent < m_tp_progress_trigger_percent) return false; sl_value = NormalizeDouble(sl_value, digits); return true; } /// @brief 高ボラティリティ判定に基づくSL候補を計算する。 /// @return いずれかの時間足でしきい値を超え、SL候補を出力した場合は true。 bool CalcHighVolatilitySL(const ENUM_POSITION_TYPE type, const double current_price, const double open_m1, const double open_m3, const double open_m5, const double open_m10, const double open_m15, const double pip_size, const int digits, double &sl_value) { bool has_candidate = false; double candidate_sl = 0.0; const double rate_ratio = 0.9; EvaluateHighVolatilityOpen(type, current_price, open_m1, 100.0, rate_ratio, pip_size, digits, has_candidate, candidate_sl); EvaluateHighVolatilityOpen(type, current_price, open_m3, 150.0, rate_ratio, pip_size, digits, has_candidate, candidate_sl); EvaluateHighVolatilityOpen(type, current_price, open_m5, 200.0, rate_ratio, pip_size, digits, has_candidate, candidate_sl); EvaluateHighVolatilityOpen(type, current_price, open_m10, 300.0, rate_ratio, pip_size, digits, has_candidate, candidate_sl); EvaluateHighVolatilityOpen(type, current_price, open_m15, 400.0, rate_ratio, pip_size, digits, has_candidate, candidate_sl); if (!has_candidate) return false; sl_value = NormalizeDouble(candidate_sl, digits); return true; } /// @brief 1本の時間足始値から急変幅を評価し、有効なSL候補なら最良候補へ反映する。 void EvaluateHighVolatilityOpen(const ENUM_POSITION_TYPE type, const double current_price, const double open_price, const double limit_pips, const double rate_ratio, const double pip_size, const int digits, bool &has_candidate, double &candidate_sl) { if (open_price <= 0.0 || pip_size <= 0.0) return; double movement_pips = 0.0; double sl_value = 0.0; if (type == POSITION_TYPE_BUY) { movement_pips = (current_price - open_price) / pip_size; sl_value = open_price + limit_pips * rate_ratio * pip_size; } else if (type == POSITION_TYPE_SELL) { movement_pips = (open_price - current_price) / pip_size; sl_value = open_price - limit_pips * rate_ratio * pip_size; } else { return; } if (movement_pips < limit_pips) return; sl_value = NormalizeDouble(sl_value, digits); UpdateBestCandidate(type, sl_value, has_candidate, candidate_sl); } /// @brief 複数ロジックから得たSL候補のうち、最も有利な値を保持する。 /// @param type ポジション種別。BUYは高いSL、SELLは低いSLを優先する。 /// @param sl_value 新しく評価するSL候補。 /// @param has_candidate 既に候補が存在するかを示す入出力フラグ。 /// @param candidate_sl 現在の最良SL候補の入出力値。 void UpdateBestCandidate(const ENUM_POSITION_TYPE type, const double sl_value, bool &has_candidate, double &candidate_sl) { if (!has_candidate) { candidate_sl = sl_value; has_candidate = true; return; } if (type == POSITION_TYPE_BUY) candidate_sl = MathMax(candidate_sl, sl_value); else candidate_sl = MathMin(candidate_sl, sl_value); } /// @brief 新しいSLが既存SLより利益保護方向へ改善しているか判定する。 /// @param type ポジション種別。 /// @param new_sl 新しく設定したいSL価格。 /// @param current_sl 現在のSL価格。未設定の場合は 0.0。 /// @return 未設定または利益保護方向へ十分に改善している場合は true。 /// @details 小数誤差による微小な再変更を避けるため、pointの10%を許容差として使う。 bool IsBetterStopLoss(const ENUM_POSITION_TYPE type, const double new_sl, const double current_sl) { const double point = SymbolInfoDouble(m_symbol, SYMBOL_POINT); const double tolerance = point * 0.1; if (current_sl == 0.0) return true; if (type == POSITION_TYPE_BUY) return (new_sl > current_sl + tolerance); return (new_sl < current_sl - tolerance); } /// @brief ブローカーのストップレベルとフリーズレベルに対してSL変更が可能か判定する。 /// @param type ポジション種別。 /// @param market_price BUYはBid、SELLはAskを想定した現在価格。 /// @param new_sl 新しく設定したいSL価格。 /// @return 現在価格から必要距離を確保できている場合は true。 bool IsStopDistanceAllowed(const ENUM_POSITION_TYPE type, const double market_price, const double new_sl) { const double point = SymbolInfoDouble(m_symbol, SYMBOL_POINT); const int stops_level = (int)SymbolInfoInteger(m_symbol, SYMBOL_TRADE_STOPS_LEVEL); const int freeze_level = (int)SymbolInfoInteger(m_symbol, SYMBOL_TRADE_FREEZE_LEVEL); const double stop_gap = stops_level * point; const double freeze_gap = freeze_level * point; if (point <= 0.0) return false; if (type == POSITION_TYPE_BUY) { if (new_sl > market_price - stop_gap) return false; if (freeze_level > 0 && new_sl > market_price - freeze_gap) return false; return true; } if (new_sl < market_price + stop_gap) return false; if (freeze_level > 0 && new_sl < market_price + freeze_gap) return false; return true; } /// @brief 対象チケットのSLを更新し、TPは現在値を維持する。 /// @param ticket 変更対象ポジションのチケット番号。 /// @param new_sl 新しいSL価格。 /// @param current_tp 変更前のTP価格。 /// @return `CTrade::PositionModify` が成功した場合は true。 /// @details 失敗時はretcode、GetLastError、設定しようとしたSLをログ出力する。 bool ModifyStopLoss(const ulong ticket, const double new_sl, const double current_tp) { ResetLastError(); if (!m_trade.PositionModify(ticket, new_sl, current_tp)) { Print("SLTPManager SL modify failed: ticket=", ticket, " symbol=", m_symbol, " magic=", m_magic, " retcode=", m_trade.ResultRetcode(), " err=", GetLastError(), " new_sl=", DoubleToString(new_sl, (int)SymbolInfoInteger(m_symbol, SYMBOL_DIGITS))); return false; } return true; } }; #endif