True Scalperプロフィットロック戦略
概要
True Scalperプロフィットロック戦略は、MetaTrader 5のエキスパートアドバイザー「True Scalper Profit Lock」のStockSharpポートです。この戦略は、高速指数移動平均、2期間RSIフィルター、ストップをブレークイーブンに移動させる利益保護ルーチンを使用した超短期取引に焦点を当てています。追加の「アバンドン」ロジックは、事前に定義されたローソク足数以内に目標に達しないトレードを強制的に閉じます。
実装は単一のローソク足ストリームをサブスクライブし、完成したローソク足のみを評価します。イントラデイスキャルピング向けに設計されていますが、すべてのパラメーターは完全に調整可能で、他の時間軸やインストゥルメントへの適応が可能です。
インジケーターとデータ
- EMA（速い） – デフォルト長さ3、遅いEMAを上方クロスしたときに強気トリガーとして機能します。
- EMA（遅い） – デフォルト長さ7、短期トレンドの方向を定義します。
- RSI – デフォルト長さ2、選択可能な意思決定モード付き：
- メソッドA（デフォルトで無効）RSIが前のローソク足からしきい値をクロスすると反応します。
- メソッドB（デフォルトで有効）しきい値に対してRSIの極性を追跡します。
- ローソク足 – デフォルトの時間軸は1分、
CandleTypeパラメーターで設定可能。
エントリーロジック
- 最新の完成したローソク足で速いEMA、遅いEMA、RSIを計算します。
- RSIの状態を評価します：
- メソッドA：2本の連続したローソク足間でしきい値がクロスされた時のみRSI極性を設定します。
- メソッドB：値がしきい値より上か下かによってRSI極性を設定します。
- 買いセットアップ – 速いEMAが遅いEMAより少なくとも1価格ステップ上にありかつRSIが負の極性を示すとトリガーされます。アバンドンロジックがロングへの反転を強制した場合、現在のシグナルに関わらずトレードも開かれます。
- 売りセットアップ – 速いEMAが遅いEMAより少なくとも1価格ステップ下にありかつRSIが正の極性を示す場合、またはアバンドン反転がショートエントリーを強制する場合にトリガーされます。
- ポジションの反転は、1つの成行注文でネットポジションを転換するために必要な差額を送ることで処理されます。
エグジットロジック
- ストップロス / テイクプロフィット – 価格ステップで設定（
StopLossPoints、TakeProfitPoints）し、エントリー直後に適用されます。 - プロフィットロック – 有効にすると、オープントレードが指定した利益（
BreakEvenTriggerPoints）を蓄積したら、ストップがブレークイーブンにオフセット（BreakEvenPoints）を加えた位置に移動します。このルーチンはロングとショートポジションの両方で機能し、トレードごとに1回だけ実行されます。 - アバンドンロジック – エントリーからの完成したローソク足数を追跡します：
- メソッドA：
AbandonBars本のローソク足後にトレードを閉じ、次の機会に反対方向のポジションを開くフラグを設定します。 - メソッドB：タイムアウト後にポジションを閉じますが、シグナルベースの方向選択はそのままにします。
- 両方のメソッドが有効な場合、メソッドAが優先されます。
- メソッドA：
- 手動エグジットは成行注文（
ClosePosition経由）で発行され、トレード状態を自動的にリセットします。
資金管理
UseMoneyManagementが有効な場合、ポジションサイズはポートフォリオ残高から導出されます：Ceiling(Balance * RiskPercent / 10000) / 10。- 管理されたボリュームは元のMT5ルールに制限されています：
InitialVolumeへの最小フォールバック、1ロット以上の値は切り上げ、オプションのミニ口座乗数、100ロットのハードキャップ。 - 無効の場合、戦略はすべての注文に固定の
InitialVolumeを使用します。
パラメーター
InitialVolume– 資金管理が無効な場合の基本ロットサイズ。TakeProfitPoints/StopLossPoints–Security.PriceStep単位の距離。FastPeriod,SlowPeriod,RsiLength,RsiThreshold– インジケーター設定。UseRsiMethodA,UseRsiMethodB– RSI意思決定ロジックの切り替え。UseAbandonMethodA,UseAbandonMethodB,AbandonBars– タイムアウト管理の設定。UseMoneyManagement,RiskPercent,LiveTrading,IsMiniAccount– MT5エキスパートアドバイザーと整合したリスクサイジングオプション。UseProfitLock,BreakEvenTriggerPoints,BreakEvenPoints– ブレークイーブンパラメーター。MaxPositions– MLQバージョンとの互換性のために保持（StockSharpポートはインストゥルメントごとに単一のネットポジションを管理）。CandleType– シグナル生成のための時間軸またはカスタムローソク足タイプ。
使用上の注意
- 戦略を単一のインストゥルメントに付加してください。
GetWorkingSecuritiesオーバーライドは選択されたローソク足タイプに自動的にサブスクライブします。 - プロフィットロックとアバンドン機能は完成したローソク足に依存します。同じローソク足内で元に戻るバー内の価格スパイクは無視されます。
- 元のMT5パラメーター
Slippageはソースコードで使用されておらず、したがって存在しません。 - 意図したpip距離を維持するために、取引するインストゥルメントに応じて
Security.PriceStepまたはステップベースのパラメーターを調整してください。
変換の違い
- StockSharpはネットポジションで動作するため、
MaxPositionsが1より大きくても同時に複数のポジションが開かれません。これはmaxTradesPerPairが1のときの元のエキスパートの典型的なネッティング動作を反映しています。 - 注文管理はチケットの直接操作の代わりに
BuyMarket、SellMarket、ClosePositionヘルパーを使用します。 - インジケーターデータは手動バッファアクセスを避けるために
Bindコールバックを通じて配信されます。
テストの推奨事項
- 元のEAで使用されたのと同じ時間軸（1分足ローソク足）で過去のデータの動作を検証してください。
- これらはforex見積もり向けに調整されたため、対象インストゥルメントの
TakeProfitPoints、StopLossPoints、BreakEvenTriggerPointsを最適化してください。
using System;
using System.Linq;
using System.Collections.Generic;
using Ecng.Common;
using Ecng.Collections;
using Ecng.Serialization;
using StockSharp.Algo.Indicators;
using StockSharp.Algo.Strategies;
using StockSharp.BusinessEntities;
using StockSharp.Messages;
namespace StockSharp.Samples.Strategies;
/// <summary>
/// True Scalper Profit Lock strategy converted from MetaTrader 5.
/// Combines short-term exponential moving averages with RSI filters, profit locking and abandon logic.
/// </summary>
public class TrueScalperProfitLockStrategy : Strategy
{
private readonly StrategyParam<decimal> _initialVolume;
private readonly StrategyParam<decimal> _takeProfitPoints;
private readonly StrategyParam<decimal> _stopLossPoints;
private readonly StrategyParam<int> _fastPeriod;
private readonly StrategyParam<int> _slowPeriod;
private readonly StrategyParam<int> _rsiLength;
private readonly StrategyParam<decimal> _rsiThreshold;
private readonly StrategyParam<bool> _useRsiMethodA;
private readonly StrategyParam<bool> _useRsiMethodB;
private readonly StrategyParam<bool> _useAbandonMethodA;
private readonly StrategyParam<bool> _useAbandonMethodB;
private readonly StrategyParam<int> _abandonBars;
private readonly StrategyParam<bool> _useMoneyManagement;
private readonly StrategyParam<decimal> _riskPercent;
private readonly StrategyParam<bool> _useProfitLock;
private readonly StrategyParam<decimal> _breakEvenTriggerPoints;
private readonly StrategyParam<decimal> _breakEvenPoints;
private readonly StrategyParam<bool> _liveTrading;
private readonly StrategyParam<bool> _isMiniAccount;
private readonly StrategyParam<int> _maxPositions;
private readonly StrategyParam<DataType> _candleType;
private decimal? _entryPrice;
private decimal? _stopLossPrice;
private decimal? _takeProfitPrice;
private decimal? _previousRsi;
private decimal _currentVolume;
private bool _isLongPosition;
private bool _pendingReverseToBuy;
private bool _pendingReverseToSell;
private int _barsSinceEntry;
private DateTimeOffset? _lastCandleTime;
private bool _breakEvenApplied;
/// <summary>
/// Base order size expressed in lots.
/// </summary>
public decimal InitialVolume
{
get => _initialVolume.Value;
set => _initialVolume.Value = value;
}
/// <summary>
/// Take profit distance in price steps.
/// </summary>
public decimal TakeProfitPoints
{
get => _takeProfitPoints.Value;
set => _takeProfitPoints.Value = value;
}
/// <summary>
/// Stop loss distance in price steps.
/// </summary>
public decimal StopLossPoints
{
get => _stopLossPoints.Value;
set => _stopLossPoints.Value = value;
}
/// <summary>
/// Fast EMA period.
/// </summary>
public int FastPeriod
{
get => _fastPeriod.Value;
set => _fastPeriod.Value = value;
}
/// <summary>
/// Slow EMA period.
/// </summary>
public int SlowPeriod
{
get => _slowPeriod.Value;
set => _slowPeriod.Value = value;
}
/// <summary>
/// RSI calculation length.
/// </summary>
public int RsiLength
{
get => _rsiLength.Value;
set => _rsiLength.Value = value;
}
/// <summary>
/// RSI decision threshold.
/// </summary>
public decimal RsiThreshold
{
get => _rsiThreshold.Value;
set => _rsiThreshold.Value = value;
}
/// <summary>
/// Enable RSI crossing logic.
/// </summary>
public bool UseRsiMethodA
{
get => _useRsiMethodA.Value;
set => _useRsiMethodA.Value = value;
}
/// <summary>
/// Enable RSI polarity logic.
/// </summary>
public bool UseRsiMethodB
{
get => _useRsiMethodB.Value;
set => _useRsiMethodB.Value = value;
}
/// <summary>
/// Force reverse direction after abandon timeout.
/// </summary>
public bool UseAbandonMethodA
{
get => _useAbandonMethodA.Value;
set => _useAbandonMethodA.Value = value;
}
/// <summary>
/// Close the trade after abandon timeout without forcing direction.
/// </summary>
public bool UseAbandonMethodB
{
get => _useAbandonMethodB.Value;
set => _useAbandonMethodB.Value = value;
}
/// <summary>
/// Number of finished candles before abandon logic triggers.
/// </summary>
public int AbandonBars
{
get => _abandonBars.Value;
set => _abandonBars.Value = value;
}
/// <summary>
/// Enable balance based position sizing.
/// </summary>
public bool UseMoneyManagement
{
get => _useMoneyManagement.Value;
set => _useMoneyManagement.Value = value;
}
/// <summary>
/// Risk percentage used in money management.
/// </summary>
public decimal RiskPercent
{
get => _riskPercent.Value;
set => _riskPercent.Value = value;
}
/// <summary>
/// Enable break even stop adjustment.
/// </summary>
public bool UseProfitLock
{
get => _useProfitLock.Value;
set => _useProfitLock.Value = value;
}
/// <summary>
/// Profit distance that triggers break even move.
/// </summary>
public decimal BreakEvenTriggerPoints
{
get => _breakEvenTriggerPoints.Value;
set => _breakEvenTriggerPoints.Value = value;
}
/// <summary>
/// Stop offset applied once break even activates.
/// </summary>
public decimal BreakEvenPoints
{
get => _breakEvenPoints.Value;
set => _breakEvenPoints.Value = value;
}
/// <summary>
/// Use live trading sizing adjustments.
/// </summary>
public bool LiveTrading
{
get => _liveTrading.Value;
set => _liveTrading.Value = value;
}
/// <summary>
/// Treat account as mini when applying live adjustments.
/// </summary>
public bool IsMiniAccount
{
get => _isMiniAccount.Value;
set => _isMiniAccount.Value = value;
}
/// <summary>
/// Maximum simultaneous trades allowed by the original logic.
/// </summary>
public int MaxPositions
{
get => _maxPositions.Value;
set => _maxPositions.Value = value;
}
/// <summary>
/// Candle type used for signal generation.
/// </summary>
public DataType CandleType
{
get => _candleType.Value;
set => _candleType.Value = value;
}
/// <summary>
/// Initializes a new instance of the <see cref="TrueScalperProfitLockStrategy"/> class.
/// </summary>
public TrueScalperProfitLockStrategy()
{
_initialVolume = Param(nameof(InitialVolume), 1m)
.SetGreaterThanZero()
.SetDisplay("Lots", "Base trade volume", "Risk");
_takeProfitPoints = Param(nameof(TakeProfitPoints), 44m)
.SetGreaterThanZero()
.SetDisplay("Take Profit", "Take profit distance in steps", "Risk")
.SetOptimize(20m, 80m, 5m);
_stopLossPoints = Param(nameof(StopLossPoints), 90m)
.SetGreaterThanZero()
.SetDisplay("Stop Loss", "Stop loss distance in steps", "Risk")
.SetOptimize(50m, 150m, 10m);
_fastPeriod = Param(nameof(FastPeriod), 3)
.SetGreaterThanZero()
.SetDisplay("Fast EMA", "Fast EMA length", "Signals");
_slowPeriod = Param(nameof(SlowPeriod), 7)
.SetGreaterThanZero()
.SetDisplay("Slow EMA", "Slow EMA length", "Signals");
_rsiLength = Param(nameof(RsiLength), 2)
.SetGreaterThanZero()
.SetDisplay("RSI Length", "RSI calculation length", "Signals");
_rsiThreshold = Param(nameof(RsiThreshold), 50m)
.SetDisplay("RSI Threshold", "RSI boundary for polarity", "Signals")
.SetOptimize(40m, 60m, 5m);
_useRsiMethodA = Param(nameof(UseRsiMethodA), true)
.SetDisplay("RSI Method A", "Use RSI crossing logic", "Signals");
_useRsiMethodB = Param(nameof(UseRsiMethodB), false)
.SetDisplay("RSI Method B", "Use RSI polarity logic", "Signals");
_useAbandonMethodA = Param(nameof(UseAbandonMethodA), true)
.SetDisplay("Abandon Method A", "Force reverse after timeout", "Management");
_useAbandonMethodB = Param(nameof(UseAbandonMethodB), false)
.SetDisplay("Abandon Method B", "Only close after timeout", "Management");
_abandonBars = Param(nameof(AbandonBars), 101)
.SetGreaterThanZero()
.SetDisplay("Abandon Bars", "Bars before abandon logic", "Management");
_useMoneyManagement = Param(nameof(UseMoneyManagement), true)
.SetDisplay("Money Management", "Enable balance based sizing", "Risk");
_riskPercent = Param(nameof(RiskPercent), 2m)
.SetGreaterThanZero()
.SetDisplay("Risk %", "Risk percentage per trade", "Risk");
_useProfitLock = Param(nameof(UseProfitLock), true)
.SetDisplay("Use Profit Lock", "Move stop to break even", "Risk");
_breakEvenTriggerPoints = Param(nameof(BreakEvenTriggerPoints), 25m)
.SetGreaterThanZero()
.SetDisplay("BreakEven Trigger", "Profit distance before break even", "Risk");
_breakEvenPoints = Param(nameof(BreakEvenPoints), 3m)
.SetGreaterThanZero()
.SetDisplay("BreakEven Offset", "Offset applied at break even", "Risk");
_liveTrading = Param(nameof(LiveTrading), false)
.SetDisplay("Live Trading", "Apply live sizing adjustments", "Risk");
_isMiniAccount = Param(nameof(IsMiniAccount), false)
.SetDisplay("Mini Account", "Treat account as mini", "Risk");
_maxPositions = Param(nameof(MaxPositions), 1)
.SetGreaterThanZero()
.SetDisplay("Max Positions", "Maximum simultaneous trades", "Management");
_candleType = Param(nameof(CandleType), TimeSpan.FromMinutes(30).TimeFrame())
.SetDisplay("Candle Type", "Candle type for processing", "General");
}
/// <inheritdoc />
protected override void OnReseted()
{
base.OnReseted();
_entryPrice = null;
_stopLossPrice = null;
_takeProfitPrice = null;
_previousRsi = null;
_currentVolume = 0m;
_isLongPosition = false;
_pendingReverseToBuy = false;
_pendingReverseToSell = false;
_barsSinceEntry = 0;
_lastCandleTime = null;
_breakEvenApplied = false;
}
/// <inheritdoc />
public override IEnumerable<(Security sec, DataType dt)> GetWorkingSecurities()
{
return [(Security, CandleType)];
}
/// <inheritdoc />
protected override void OnStarted2(DateTime time)
{
base.OnStarted2(time);
var fastEma = new EMA { Length = FastPeriod };
var slowEma = new EMA { Length = SlowPeriod };
var rsi = new RSI { Length = RsiLength };
SubscribeCandles(CandleType)
.Bind(fastEma, slowEma, rsi, ProcessCandle)
.Start();
}
private void ProcessCandle(ICandleMessage candle, decimal fastEma, decimal slowEma, decimal rsi)
{
if (candle.State != CandleStates.Finished)
return;
UpdateBarCounter(candle);
var step = GetPriceStep();
ApplyAbandonLogic();
if (Position != 0)
{
ApplyProfitLock(step, candle);
if (TryExitByTargets(candle))
{
_pendingReverseToBuy = false;
_pendingReverseToSell = false;
}
}
if (!IsFormedAndOnlineAndAllowTrading())
{
_previousRsi = rsi;
return;
}
var (rsiPositive, rsiNegative) = EvaluateRsiSignals(rsi);
var buySignal = fastEma > slowEma + step && rsiNegative;
var sellSignal = fastEma < slowEma - step && rsiPositive;
TryEnterPosition(candle, step, buySignal, sellSignal);
_previousRsi = rsi;
}
private void UpdateBarCounter(ICandleMessage candle)
{
if (_lastCandleTime == candle.OpenTime)
return;
if (Position != 0 && _lastCandleTime != null)
_barsSinceEntry++;
else if (Position == 0)
_barsSinceEntry = 0;
_lastCandleTime = candle.OpenTime;
}
private decimal GetPriceStep()
{
var step = Security?.PriceStep ?? 0m;
if (step <= 0)
step = 0.0001m;
return step;
}
private void ApplyAbandonLogic()
{
if (Position == 0 || AbandonBars <= 0)
return;
if (_barsSinceEntry < AbandonBars)
return;
if (UseAbandonMethodA)
{
if (_isLongPosition && Position > 0)
{
if (Position > 0) SellMarket(); else if (Position < 0) BuyMarket();
ResetTradeState();
_pendingReverseToSell = true;
_pendingReverseToBuy = false;
}
else if (!_isLongPosition && Position < 0)
{
if (Position > 0) SellMarket(); else if (Position < 0) BuyMarket();
ResetTradeState();
_pendingReverseToBuy = true;
_pendingReverseToSell = false;
}
}
else if (UseAbandonMethodB)
{
if (Position > 0) SellMarket(); else if (Position < 0) BuyMarket();
ResetTradeState();
_pendingReverseToBuy = false;
_pendingReverseToSell = false;
}
}
private void ApplyProfitLock(decimal step, ICandleMessage candle)
{
if (!UseProfitLock || _entryPrice is not decimal entry || _stopLossPrice is not decimal stop)
return;
if (_isLongPosition && Position > 0)
{
if (!_breakEvenApplied && stop < entry && BreakEvenTriggerPoints > 0m && candle.HighPrice >= entry + step * BreakEvenTriggerPoints)
{
_stopLossPrice = entry + step * BreakEvenPoints;
_breakEvenApplied = true;
}
}
else if (!_isLongPosition && Position < 0)
{
if (!_breakEvenApplied && stop > entry && BreakEvenTriggerPoints > 0m && candle.LowPrice <= entry - step * BreakEvenTriggerPoints)
{
_stopLossPrice = entry - step * BreakEvenPoints;
_breakEvenApplied = true;
}
}
}
private bool TryExitByTargets(ICandleMessage candle)
{
if (_entryPrice is null || _stopLossPrice is null || _takeProfitPrice is null)
return false;
if (_isLongPosition && Position > 0)
{
if (candle.HighPrice >= _takeProfitPrice)
{
if (Position > 0) SellMarket(); else if (Position < 0) BuyMarket();
ResetTradeState();
return true;
}
if (candle.LowPrice <= _stopLossPrice)
{
if (Position > 0) SellMarket(); else if (Position < 0) BuyMarket();
ResetTradeState();
return true;
}
}
else if (!_isLongPosition && Position < 0)
{
if (candle.LowPrice <= _takeProfitPrice)
{
if (Position > 0) SellMarket(); else if (Position < 0) BuyMarket();
ResetTradeState();
return true;
}
if (candle.HighPrice >= _stopLossPrice)
{
if (Position > 0) SellMarket(); else if (Position < 0) BuyMarket();
ResetTradeState();
return true;
}
}
return false;
}
private (bool positive, bool negative) EvaluateRsiSignals(decimal currentRsi)
{
var positive = false;
var negative = false;
if (UseRsiMethodA && _previousRsi is decimal prev)
{
if (currentRsi > RsiThreshold && prev < RsiThreshold)
{
positive = true;
negative = false;
}
else if (currentRsi < RsiThreshold && prev > RsiThreshold)
{
positive = false;
negative = true;
}
}
if (UseRsiMethodB)
{
if (currentRsi > RsiThreshold)
{
positive = true;
negative = false;
}
else if (currentRsi < RsiThreshold)
{
positive = false;
negative = true;
}
}
return (positive, negative);
}
private void TryEnterPosition(ICandleMessage candle, decimal step, bool buySignal, bool sellSignal)
{
if (MaxPositions <= 0)
return;
var volume = CalculateEntryVolume();
if (volume <= 0)
return;
if ((_pendingReverseToBuy || buySignal) && Position <= 0)
{
var totalVolume = volume + (Position < 0 ? Math.Abs(Position) : 0m);
if (totalVolume <= 0)
return;
BuyMarket();
InitializeTradeState(candle, step, volume, true);
_pendingReverseToBuy = false;
_pendingReverseToSell = false;
}
else if ((_pendingReverseToSell || sellSignal) && Position >= 0)
{
var totalVolume = volume + (Position > 0 ? Math.Abs(Position) : 0m);
if (totalVolume <= 0)
return;
SellMarket();
InitializeTradeState(candle, step, volume, false);
_pendingReverseToBuy = false;
_pendingReverseToSell = false;
}
}
private decimal CalculateEntryVolume()
{
var volume = InitialVolume;
if (UseMoneyManagement)
{
var balance = Portfolio?.CurrentValue ?? Portfolio?.BeginValue ?? 0m;
if (balance > 0)
{
var managed = Math.Ceiling(balance * RiskPercent / 10000m) / 10m;
if (managed < 0.1m)
managed = InitialVolume;
if (managed > 1m)
managed = Math.Ceiling(managed);
if (LiveTrading)
{
if (IsMiniAccount)
managed *= 10m;
else if (managed < 1m)
managed = 1m;
}
if (managed > 100m)
managed = 100m;
volume = managed;
}
}
return Math.Max(volume, 0m);
}
private void InitializeTradeState(ICandleMessage candle, decimal step, decimal volume, bool isLong)
{
_isLongPosition = isLong;
_entryPrice = candle.ClosePrice;
_currentVolume = volume;
_breakEvenApplied = false;
_barsSinceEntry = 0;
_lastCandleTime = candle.OpenTime;
if (isLong)
{
_stopLossPrice = _entryPrice - step * StopLossPoints;
_takeProfitPrice = _entryPrice + step * TakeProfitPoints;
}
else
{
_stopLossPrice = _entryPrice + step * StopLossPoints;
_takeProfitPrice = _entryPrice - step * TakeProfitPoints;
}
}
private void ResetTradeState()
{
_entryPrice = null;
_stopLossPrice = null;
_takeProfitPrice = null;
_currentVolume = 0m;
_breakEvenApplied = false;
_barsSinceEntry = 0;
}
}
import clr
clr.AddReference("StockSharp.Messages")
clr.AddReference("StockSharp.Algo")
clr.AddReference("StockSharp.Algo.Indicators")
clr.AddReference("StockSharp.Algo.Strategies")
from System import TimeSpan
from StockSharp.Messages import DataType, CandleStates
from StockSharp.Algo.Indicators import ExponentialMovingAverage, RelativeStrengthIndex
from StockSharp.Algo.Strategies import Strategy
class true_scalper_profit_lock_strategy(Strategy):
def __init__(self):
super(true_scalper_profit_lock_strategy, self).__init__()
self._tp_points = self.Param("TakeProfitPoints", 44.0)
self._sl_points = self.Param("StopLossPoints", 90.0)
self._fast_period = self.Param("FastPeriod", 3)
self._slow_period = self.Param("SlowPeriod", 7)
self._rsi_length = self.Param("RsiLength", 2)
self._rsi_threshold = self.Param("RsiThreshold", 50.0)
self._abandon_bars = self.Param("AbandonBars", 101)
self._be_trigger = self.Param("BreakEvenTrigger", 25.0)
self._be_offset = self.Param("BreakEvenOffset", 3.0)
self._candle_type = self.Param("CandleType", DataType.TimeFrame(TimeSpan.FromMinutes(30)))
@property
def CandleType(self): return self._candle_type.Value
@CandleType.setter
def CandleType(self, value): self._candle_type.Value = value
def OnReseted(self):
super(true_scalper_profit_lock_strategy, self).OnReseted()
self._entry_price = 0
self._stop_price = 0
self._take_price = 0
self._prev_rsi = 0
self._is_long = False
self._bars_since_entry = 0
self._be_applied = False
def OnStarted2(self, time):
super(true_scalper_profit_lock_strategy, self).OnStarted2(time)
self._entry_price = 0
self._stop_price = 0
self._take_price = 0
self._prev_rsi = 0
self._is_long = False
self._bars_since_entry = 0
self._be_applied = False
fast = ExponentialMovingAverage()
fast.Length = self._fast_period.Value
slow = ExponentialMovingAverage()
slow.Length = self._slow_period.Value
rsi = RelativeStrengthIndex()
rsi.Length = self._rsi_length.Value
sub = self.SubscribeCandles(self.CandleType)
sub.Bind(fast, slow, rsi, self.OnProcess).Start()
area = self.CreateChartArea()
if area is not None:
self.DrawCandles(area, sub)
self.DrawOwnTrades(area)
def OnProcess(self, candle, fast_val, slow_val, rsi_val):
if candle.State != CandleStates.Finished:
return
fast_val = float(fast_val)
slow_val = float(slow_val)
rsi_val = float(rsi_val)
close = float(candle.ClosePrice)
high = float(candle.HighPrice)
low = float(candle.LowPrice)
step = 1.0
# Count bars since entry
if self.Position != 0:
self._bars_since_entry += 1
else:
self._bars_since_entry = 0
# Abandon logic
if self.Position != 0 and self._bars_since_entry >= self._abandon_bars.Value:
if self.Position > 0:
self.SellMarket()
elif self.Position < 0:
self.BuyMarket()
self._reset_trade()
self._prev_rsi = rsi_val
return
# Break-even
if self.Position != 0 and self._entry_price > 0 and not self._be_applied:
trigger = self._be_trigger.Value * step
offset = self._be_offset.Value * step
if self._is_long and self.Position > 0:
if high >= self._entry_price + trigger:
new_stop = self._entry_price + offset
if new_stop > self._stop_price:
self._stop_price = new_stop
self._be_applied = True
elif not self._is_long and self.Position < 0:
if low <= self._entry_price - trigger:
new_stop = self._entry_price - offset
if self._stop_price == 0 or new_stop < self._stop_price:
self._stop_price = new_stop
self._be_applied = True
# SL/TP exits
if self._is_long and self.Position > 0:
if self._take_price > 0 and high >= self._take_price:
self.SellMarket()
self._reset_trade()
self._prev_rsi = rsi_val
return
if self._stop_price > 0 and low <= self._stop_price:
self.SellMarket()
self._reset_trade()
self._prev_rsi = rsi_val
return
elif not self._is_long and self.Position < 0:
if self._take_price > 0 and low <= self._take_price:
self.BuyMarket()
self._reset_trade()
self._prev_rsi = rsi_val
return
if self._stop_price > 0 and high >= self._stop_price:
self.BuyMarket()
self._reset_trade()
self._prev_rsi = rsi_val
return
# RSI signals
rsi_positive = False
rsi_negative = False
if self._prev_rsi > 0:
thr = self._rsi_threshold.Value
if rsi_val > thr and self._prev_rsi < thr:
rsi_positive = True
elif rsi_val < thr and self._prev_rsi > thr:
rsi_negative = True
buy_signal = fast_val > slow_val + step and rsi_negative
sell_signal = fast_val < slow_val - step and rsi_positive
if buy_signal and self.Position <= 0:
if self.Position < 0:
self.BuyMarket()
self.BuyMarket()
self._entry_price = close
self._is_long = True
self._stop_price = close - step * self._sl_points.Value
self._take_price = close + step * self._tp_points.Value
self._be_applied = False
self._bars_since_entry = 0
elif sell_signal and self.Position >= 0:
if self.Position > 0:
self.SellMarket()
self.SellMarket()
self._entry_price = close
self._is_long = False
self._stop_price = close + step * self._sl_points.Value
self._take_price = close - step * self._tp_points.Value
self._be_applied = False
self._bars_since_entry = 0
self._prev_rsi = rsi_val
def _reset_trade(self):
self._entry_price = 0
self._stop_price = 0
self._take_price = 0
self._be_applied = False
self._bars_since_entry = 0
def CreateClone(self):
return true_scalper_profit_lock_strategy()