Deutsch DE
Auf GitHub ansehen

Shooting-Star-Muster (Shooting Star Pattern)

Die Shooting-Star-Kerze erscheint oft nach einem Anstieg und warnt vor einer Umkehr. Diese Strategie sucht nach einem langen oberen Docht im Verhältnis zum Kerzenkörper und kaum einem unteren Docht.

Tests zeigen eine durchschnittliche jährliche Rendite von etwa 67 %. Die Strategie eignet sich am besten für den Aktienmarkt.

Wenn eine Bestätigung erforderlich ist, muss die nächste Kerze tiefer schließen, bevor eine Short-Position eingegangen wird. Andernfalls kann der Trade sofort eingegangen werden. Stops werden oberhalb des Musthochs platziert.

Details

  • Einstiegskriterien: Shooting Star erkannt und Bestätigung, falls aktiviert.
  • Long/Short: Nur Short.
  • Ausstiegskriterien: Stop-Loss oder diskretionärer Ausstieg.
  • Stops: Ja.
  • Standardwerte:
    • ShadowToBodyRatio = 2.0m
    • CandleType = TimeSpan.FromMinutes(15)
    • StopLossPercent = 1.0m
    • ConfirmationRequired = true
  • Filter:
    • Kategorie: Muster
    • Richtung: Nur Short
    • Indikatoren: Candlestick
    • Stops: Ja
    • Komplexität: Mittel
    • Zeitrahmen: Intraday
    • Saisonalität: Nein
    • Neuronale Netze: Nein
    • Divergenz: Nein
    • Risikolevel: Mittel
using System;
using System.Collections.Generic;

using Ecng.Common;

using StockSharp.Algo.Indicators;
using StockSharp.Algo.Strategies;
using StockSharp.BusinessEntities;
using StockSharp.Messages;

namespace StockSharp.Samples.Strategies;

/// <summary>
/// Shooting Star strategy.
/// Enters short on shooting star pattern (long upper shadow, small lower shadow).
/// Enters long on inverted shooting star (long lower shadow, small upper shadow).
/// Exits via SMA crossover.
/// </summary>
public class ShootingStarStrategy : Strategy
{
	private readonly StrategyParam<decimal> _shadowToBodyRatio;
	private readonly StrategyParam<int> _maPeriod;
	private readonly StrategyParam<DataType> _candleType;
	private readonly StrategyParam<int> _cooldownBars;

	private int _cooldown;

	/// <summary>
	/// Shadow to body ratio.
	/// </summary>
	public decimal ShadowToBodyRatio
	{
		get => _shadowToBodyRatio.Value;
		set => _shadowToBodyRatio.Value = value;
	}

	/// <summary>
	/// MA Period for exit.
	/// </summary>
	public int MAPeriod
	{
		get => _maPeriod.Value;
		set => _maPeriod.Value = value;
	}

	/// <summary>
	/// Type of candles to use.
	/// </summary>
	public DataType CandleType
	{
		get => _candleType.Value;
		set => _candleType.Value = value;
	}

	/// <summary>
	/// Cooldown bars between trades.
	/// </summary>
	public int CooldownBars
	{
		get => _cooldownBars.Value;
		set => _cooldownBars.Value = value;
	}

	/// <summary>
	/// Constructor.
	/// </summary>
	public ShootingStarStrategy()
	{
		_shadowToBodyRatio = Param(nameof(ShadowToBodyRatio), 2.0m)
			.SetRange(1.5m, 5.0m)
			.SetDisplay("Shadow/Body Ratio", "Min ratio of shadow to body", "Pattern");

		_maPeriod = Param(nameof(MAPeriod), 20)
			.SetGreaterThanZero()
			.SetDisplay("MA Period", "Period for SMA", "Indicators");

		_candleType = Param(nameof(CandleType), TimeSpan.FromMinutes(1).TimeFrame())
			.SetDisplay("Candle Type", "Type of candles to use", "General");

		_cooldownBars = Param(nameof(CooldownBars), 500)
			.SetRange(1, 1000)
			.SetDisplay("Cooldown Bars", "Bars to wait between trades", "General");
	}

	/// <inheritdoc />
	public override IEnumerable<(Security sec, DataType dt)> GetWorkingSecurities()
	{
		return [(Security, CandleType)];
	}

	/// <inheritdoc />
	protected override void OnReseted()
	{
		base.OnReseted();
		_cooldown = default;
	}

	/// <inheritdoc />
	protected override void OnStarted2(DateTime time)
	{
		base.OnStarted2(time);

		_cooldown = 0;

		var sma = new SimpleMovingAverage { Length = MAPeriod };

		var subscription = SubscribeCandles(CandleType);
		subscription
			.Bind(sma, ProcessCandle)
			.Start();

		var area = CreateChartArea();
		if (area != null)
		{
			DrawCandles(area, subscription);
			DrawIndicator(area, sma);
			DrawOwnTrades(area);
		}
	}

	private void ProcessCandle(ICandleMessage candle, decimal smaValue)
	{
		if (candle.State != CandleStates.Finished)
			return;

		if (!IsFormedAndOnlineAndAllowTrading())
			return;

		if (_cooldown > 0)
		{
			_cooldown--;
			return;
		}

		var bodySize = Math.Abs(candle.OpenPrice - candle.ClosePrice);
		var upperShadow = candle.HighPrice - Math.Max(candle.OpenPrice, candle.ClosePrice);
		var lowerShadow = Math.Min(candle.OpenPrice, candle.ClosePrice) - candle.LowPrice;

		// Shooting star: long upper shadow, small lower shadow (bearish)
		var isShootingStar = bodySize > 0 && upperShadow > bodySize * ShadowToBodyRatio && lowerShadow < bodySize * 0.5m;
		// Hammer: long lower shadow, small upper shadow (bullish)
		var isHammer = bodySize > 0 && lowerShadow > bodySize * ShadowToBodyRatio && upperShadow < bodySize * 0.5m;

		if (Position == 0 && isShootingStar && candle.ClosePrice > smaValue)
		{
			SellMarket();
			_cooldown = CooldownBars;
		}
		else if (Position == 0 && isHammer && candle.ClosePrice < smaValue)
		{
			BuyMarket();
			_cooldown = CooldownBars;
		}
		else if (Position > 0 && candle.ClosePrice < smaValue)
		{
			SellMarket();
			_cooldown = CooldownBars;
		}
		else if (Position < 0 && candle.ClosePrice > smaValue)
		{
			BuyMarket();
			_cooldown = CooldownBars;
		}
	}
}