Galactic Explosion Strategy

Overview

The Galactic Explosion strategy rebuilds the original MetaTrader 5 grid expert in StockSharp. It operates on finished candles, uses a long-term moving average to define the directional bias, and deploys an expanding grid of orders. The system accumulates trades when price stays on one side of the moving average and closes the entire basket once a predefined profit target is achieved.

Market Logic

Directional filter – the strategy compares the latest candle close with a moving average. When price closes below the average the bias turns bullish, and when price closes above the average the bias becomes bearish.
Progressive grid – the first eight entries are taken whenever the bias allows. After the eighth position the distance between the current price and both the last and first entries controls whether additional trades are allowed.
Spacing control – distances are measured in price steps. If price has moved far enough from the last entry the strategy will add to the basket. Depending on the distance to the very first entry it will either trade immediately, skip three candles, or skip six candles before adding again.
Profit realisation – realised PnL plus the open profit of the basket is compared to the minimal profit target. When the threshold is met every open position is closed in a single market order.

Trade Management

Entry volume – every trade is executed with the configured order volume. When the signal flips while holding a position the strategy sends a single order that closes the old side and opens a new one with the required extra volume.
Position tracking – the strategy keeps the average price and the first/last entry price for long and short baskets independently. This allows it to reproduce the distance-based scaling rules of the original expert.
Session filter – trading is only active between the configured start and end hours. The logic uses the candle opening time and ignores signals outside of this window.
Safety check – if the trading window is misconfigured (for example, the start hour is not earlier than the end hour) the strategy skips trading and logs a warning.

Parameters

Parameter	Description
Order Volume	Volume used for each new entry. This value is also used to estimate how many grid steps are currently open.
Start Hour	Start of the trading session in exchange time. Signals before this hour are ignored.
End Hour	End of the trading session (exclusive). Signals after this hour are ignored.
Minimal Profit	Combined realised plus unrealised profit that triggers closing all open positions.
Indent After 8th	Minimum distance (in price steps) from the most recent entry after eight trades before another position can be opened.
Skip 3 Min	Lower bound (in price steps) for activating the “skip three candles” rule.
Skip 3 Max	Upper bound (in price steps) that keeps the “skip three candles” rule active.
Skip 6 Max	Upper bound (in price steps) that keeps the “skip six candles” rule active.
MA Length	Length of the simple moving average that defines the directional bias.
Candle Type	Candle series subscribed by the strategy. The moving average and grid logic run on this data stream.

Implementation Notes

The strategy uses SubscribeCandles with a SimpleMovingAverage indicator and processes only finished candles.
Position statistics are maintained through OnNewMyTrade, enabling precise tracking of the first and last entry prices as well as average prices for open baskets.
Distance thresholds are scaled by the security PriceStep, reproducing the original pip-based configuration of the MT5 expert.
The implementation avoids custom collections and focuses on scalar state variables to comply with the project guidelines.

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>
/// Strategy that recreates the Galactic Explosion grid behavior using a moving average bias and distance based scaling.
/// </summary>
public class GalacticExplosionStrategy : Strategy
{
	private readonly StrategyParam<decimal> _orderVolume;
	private readonly StrategyParam<int> _startHour;
	private readonly StrategyParam<int> _endHour;
	private readonly StrategyParam<decimal> _minimalProfit;
	private readonly StrategyParam<decimal> _indentAfterEighth;
	private readonly StrategyParam<decimal> _skipThreeCandlesMin;
	private readonly StrategyParam<decimal> _skipThreeCandlesMax;
	private readonly StrategyParam<decimal> _skipSixCandlesMax;
	private readonly StrategyParam<int> _maLength;
	private readonly StrategyParam<DataType> _candleType;

	private SimpleMovingAverage _movingAverage;

	private int _longEntries;
	private int _shortEntries;
	private decimal _firstLongPrice;
	private decimal _lastLongPrice;
	private decimal _firstShortPrice;
	private decimal _lastShortPrice;
	private int _missedBarsLong;
	private int _missedBarsShort;
	private decimal _longPositionVolume;
	private decimal _shortPositionVolume;
	private decimal? _longAveragePrice;
	private decimal? _shortAveragePrice;
	private bool _invalidHoursLogged;

	/// <summary>
	/// Order volume used for every new entry.
	/// </summary>
	public decimal OrderVolume
	{
		get => _orderVolume.Value;
		set => _orderVolume.Value = value;
	}

	/// <summary>
	/// Trading window start hour in 24h format.
	/// </summary>
	public int StartHour
	{
		get => _startHour.Value;
		set => _startHour.Value = value;
	}

	/// <summary>
	/// Trading window end hour in 24h format.
	/// </summary>
	public int EndHour
	{
		get => _endHour.Value;
		set => _endHour.Value = value;
	}

	/// <summary>
	/// Profit threshold combining realized and open PnL at which all positions are closed.
	/// </summary>
	public decimal MinimalProfit
	{
		get => _minimalProfit.Value;
		set => _minimalProfit.Value = value;
	}

	/// <summary>
	/// Minimum distance from the most recent entry (expressed in price steps) required after the eighth trade.
	/// </summary>
	public decimal IndentAfterEighth
	{
		get => _indentAfterEighth.Value;
		set => _indentAfterEighth.Value = value;
	}

	/// <summary>
	/// Minimum distance from the first entry to trigger the skip three candles logic (in price steps).
	/// </summary>
	public decimal SkipThreeCandlesMin
	{
		get => _skipThreeCandlesMin.Value;
		set => _skipThreeCandlesMin.Value = value;
	}

	/// <summary>
	/// Maximum distance from the first entry that still keeps the skip three candles logic active (in price steps).
	/// </summary>
	public decimal SkipThreeCandlesMax
	{
		get => _skipThreeCandlesMax.Value;
		set => _skipThreeCandlesMax.Value = value;
	}

	/// <summary>
	/// Maximum distance from the first entry that keeps the skip six candles logic active (in price steps).
	/// </summary>
	public decimal SkipSixCandlesMax
	{
		get => _skipSixCandlesMax.Value;
		set => _skipSixCandlesMax.Value = value;
	}

	/// <summary>
	/// Length of the moving average filter.
	/// </summary>
	public int MaLength
	{
		get => _maLength.Value;
		set => _maLength.Value = value;
	}

	/// <summary>
	/// Candle type used for calculations.
	/// </summary>
	public DataType CandleType
	{
		get => _candleType.Value;
		set => _candleType.Value = value;
	}

	/// <summary>
	/// Initializes a new instance of <see cref="GalacticExplosionStrategy"/>.
	/// </summary>
	public GalacticExplosionStrategy()
	{
		_orderVolume = Param(nameof(OrderVolume), 0.1m)
		.SetGreaterThanZero()
		.SetDisplay("Order Volume", "Volume for each new entry", "Trading");

		_startHour = Param(nameof(StartHour), 8)
		.SetDisplay("Start Hour", "Trading session start hour", "Trading");

		_endHour = Param(nameof(EndHour), 17)
		.SetDisplay("End Hour", "Trading session end hour", "Trading");

		_minimalProfit = Param(nameof(MinimalProfit), 1m)
		.SetDisplay("Minimal Profit", "Target profit to close the grid", "Risk");

		_indentAfterEighth = Param(nameof(IndentAfterEighth), 500m)
		.SetDisplay("Indent After 8th", "Distance from last entry after eight trades (price steps)", "Grid");

		_skipThreeCandlesMin = Param(nameof(SkipThreeCandlesMin), 500m)
		.SetDisplay("Skip 3 Min", "Lower distance to start skipping three candles", "Grid");

		_skipThreeCandlesMax = Param(nameof(SkipThreeCandlesMax), 999m)
		.SetDisplay("Skip 3 Max", "Upper distance to keep skipping three candles", "Grid");

		_skipSixCandlesMax = Param(nameof(SkipSixCandlesMax), 2000m)
		.SetDisplay("Skip 6 Max", "Upper distance to keep skipping six candles", "Grid");

		_maLength = Param(nameof(MaLength), 10)
		.SetGreaterThanZero()
		.SetDisplay("MA Length", "Length of the moving average", "Filter");

		_candleType = Param(nameof(CandleType), TimeSpan.FromHours(4).TimeFrame())
		.SetDisplay("Candle Type", "Primary candle series", "General");
	}

	/// <inheritdoc />
	public override IEnumerable<(Security sec, DataType dt)> GetWorkingSecurities()
	{
		return [(Security, CandleType)];
	}

	/// <inheritdoc />
	protected override void OnReseted()
	{
		base.OnReseted();

		_longEntries = 0;
		_shortEntries = 0;
		_firstLongPrice = 0m;
		_lastLongPrice = 0m;
		_firstShortPrice = 0m;
		_lastShortPrice = 0m;
		_missedBarsLong = 0;
		_missedBarsShort = 0;
		_longPositionVolume = 0m;
		_shortPositionVolume = 0m;
		_longAveragePrice = null;
		_shortAveragePrice = null;
		_invalidHoursLogged = false;
	}

	/// <inheritdoc />
	protected override void OnStarted2(DateTime time)
	{
		base.OnStarted2(time);

		_movingAverage = new SimpleMovingAverage
		{
			Length = MaLength
		};

		var subscription = SubscribeCandles(CandleType);
		subscription
		.Bind(_movingAverage, ProcessCandle)
		.Start();

		// no protection needed
	}

	private void ProcessCandle(ICandleMessage candle, decimal maValue)
	{
		if (candle.State != CandleStates.Finished)
		return;

		if (!_movingAverage.IsFormed)
		return;

		var totalProfit = PnL + GetOpenProfit(candle.ClosePrice);
		if (MinimalProfit > 0m && totalProfit >= MinimalProfit && Position != 0m)
		{
			if (Position > 0)
				SellMarket(Position);
			else if (Position < 0)
				BuyMarket(-Position);
			return;
		}

		if (!IsFormedAndOnlineAndAllowTrading())
		return;

		if (!IsWithinTradingWindow(candle.OpenTime))
		return;

		var close = candle.ClosePrice;
		var needBuy = close < maValue;
		var needSell = close > maValue;

		var entries = GetCurrentEntries();

		if (entries <= 8)
		{
			if (needBuy)
			{
				EnterLong();
			}
			else if (needSell)
			{
				EnterShort();
			}

			return;
		}

		var priceStep = GetPriceStep();
		var indentAfterEighth = priceStep * IndentAfterEighth;
		var skipThreeMin = priceStep * SkipThreeCandlesMin;
		var skipThreeMax = priceStep * SkipThreeCandlesMax;
		var skipSixMax = priceStep * SkipSixCandlesMax;

		if (Position > 0m)
		{
			ProcessLongGrid(close, needBuy, indentAfterEighth, skipThreeMin, skipThreeMax, skipSixMax);
		}
		else if (Position < 0m)
		{
			ProcessShortGrid(close, needSell, indentAfterEighth, skipThreeMin, skipThreeMax, skipSixMax);
		}
	}

	private void ProcessLongGrid(decimal price, bool needBuy, decimal indentAfterEighth, decimal skipThreeMin, decimal skipThreeMax, decimal skipSixMax)
	{
		if (_lastLongPrice <= 0m || _firstLongPrice <= 0m)
		return;

		var lastDistance = Math.Abs(price - _lastLongPrice);
		if (lastDistance <= indentAfterEighth)
		return;

		var firstDistance = Math.Abs(price - _firstLongPrice);

		if (firstDistance < skipThreeMin)
		{
			_missedBarsLong = 0;

			if (needBuy)
			EnterLong();
		}
		else if (firstDistance <= skipThreeMax)
		{
			_missedBarsLong++;

			if (_missedBarsLong > 3)
			{
				if (needBuy)
				EnterLong();

				_missedBarsLong = 0;
			}
		}
		else if (firstDistance <= skipSixMax)
		{
			_missedBarsLong++;

			if (_missedBarsLong > 6)
			{
				if (needBuy)
				EnterLong();

				_missedBarsLong = 0;
			}
		}
	}

	private void ProcessShortGrid(decimal price, bool needSell, decimal indentAfterEighth, decimal skipThreeMin, decimal skipThreeMax, decimal skipSixMax)
	{
		if (_lastShortPrice <= 0m || _firstShortPrice <= 0m)
		return;

		var lastDistance = Math.Abs(price - _lastShortPrice);
		if (lastDistance <= indentAfterEighth)
		return;

		var firstDistance = Math.Abs(price - _firstShortPrice);

		if (firstDistance < skipThreeMin)
		{
			_missedBarsShort = 0;

			if (needSell)
			EnterShort();
		}
		else if (firstDistance <= skipThreeMax)
		{
			_missedBarsShort++;

			if (_missedBarsShort > 3)
			{
				if (needSell)
				EnterShort();

				_missedBarsShort = 0;
			}
		}
		else if (firstDistance <= skipSixMax)
		{
			_missedBarsShort++;

			if (_missedBarsShort > 6)
			{
				if (needSell)
				EnterShort();

				_missedBarsShort = 0;
			}
		}
	}

	/// <inheritdoc />
	protected override void OnOwnTradeReceived(MyTrade trade)
	{
		base.OnOwnTradeReceived(trade);

		if (trade.Trade == null)
		return;

		var price = trade.Trade.Price;
		var volume = trade.Trade.Volume;

		if (volume <= 0m)
		return;

		if (trade.Order.Side == Sides.Buy)
		{
			HandleBuyTrade(volume, price);
		}
		else if (trade.Order.Side == Sides.Sell)
		{
			HandleSellTrade(volume, price);
		}

		if (Position == 0m)
		{
			ResetLongState();
			ResetShortState();
		}
	}

	private void HandleBuyTrade(decimal volume, decimal price)
	{
		if (_shortPositionVolume > 0m)
		{
			var closingVolume = Math.Min(volume, _shortPositionVolume);
			_shortPositionVolume -= closingVolume;
			ReduceShortEntries(closingVolume);

			if (_shortPositionVolume <= 0m)
			{
				ResetShortState();
			}

			var remaining = volume - closingVolume;
			if (remaining > 0m)
			{
				AddLong(remaining, price);
			}
		}
		else
		{
			AddLong(volume, price);
		}
	}

	private void HandleSellTrade(decimal volume, decimal price)
	{
		if (_longPositionVolume > 0m)
		{
			var closingVolume = Math.Min(volume, _longPositionVolume);
			_longPositionVolume -= closingVolume;
			ReduceLongEntries(closingVolume);

			if (_longPositionVolume <= 0m)
			{
				ResetLongState();
			}

			var remaining = volume - closingVolume;
			if (remaining > 0m)
			{
				AddShort(remaining, price);
			}
		}
		else
		{
			AddShort(volume, price);
		}
	}

	private void AddLong(decimal volume, decimal price)
	{
		if (volume <= 0m)
		return;

		var previousVolume = _longPositionVolume;
		var newVolume = previousVolume + volume;

		if (newVolume <= 0m)
		return;

		if (previousVolume <= 0m)
		{
			_firstLongPrice = price;
			_missedBarsLong = 0;
		}

		_longEntries += GetEntryCountFromVolume(volume);
		_lastLongPrice = price;
		_longPositionVolume = newVolume;

		if (_longAveragePrice is decimal avg && previousVolume > 0m)
		{
			_longAveragePrice = ((avg * previousVolume) + (price * volume)) / newVolume;
		}
		else
		{
			_longAveragePrice = price;
		}
	}

	private void AddShort(decimal volume, decimal price)
	{
		if (volume <= 0m)
		return;

		var previousVolume = _shortPositionVolume;
		var newVolume = previousVolume + volume;

		if (newVolume <= 0m)
		return;

		if (previousVolume <= 0m)
		{
			_firstShortPrice = price;
			_missedBarsShort = 0;
		}

		_shortEntries += GetEntryCountFromVolume(volume);
		_lastShortPrice = price;
		_shortPositionVolume = newVolume;

		if (_shortAveragePrice is decimal avg && previousVolume > 0m)
		{
			_shortAveragePrice = ((avg * previousVolume) + (price * volume)) / newVolume;
		}
		else
		{
			_shortAveragePrice = price;
		}
	}

	private void ReduceLongEntries(decimal volume)
	{
		if (volume <= 0m || _longEntries <= 0)
		return;

		_longEntries = Math.Max(0, _longEntries - GetEntryCountFromVolume(volume));
	}

	private void ReduceShortEntries(decimal volume)
	{
		if (volume <= 0m || _shortEntries <= 0)
		return;

		_shortEntries = Math.Max(0, _shortEntries - GetEntryCountFromVolume(volume));
	}

	private void ResetLongState()
	{
		_longEntries = 0;
		_firstLongPrice = 0m;
		_lastLongPrice = 0m;
		_missedBarsLong = 0;
		_longPositionVolume = 0m;
		_longAveragePrice = null;
	}

	private void ResetShortState()
	{
		_shortEntries = 0;
		_firstShortPrice = 0m;
		_lastShortPrice = 0m;
		_missedBarsShort = 0;
		_shortPositionVolume = 0m;
		_shortAveragePrice = null;
	}

	private void EnterLong()
	{
		if (OrderVolume <= 0m)
		return;

		var volume = OrderVolume;

		if (Position < 0m)
		volume += Math.Abs(Position);

		if (volume > 0m)
		BuyMarket(volume);
	}

	private void EnterShort()
	{
		if (OrderVolume <= 0m)
		return;

		var volume = OrderVolume;

		if (Position > 0m)
		volume += Math.Abs(Position);

		if (volume > 0m)
		SellMarket(volume);
	}

	private decimal GetOpenProfit(decimal price)
	{
		if (Position > 0m && _longAveragePrice is decimal longAvg)
		return Position * (price - longAvg);

		if (Position < 0m && _shortAveragePrice is decimal shortAvg)
		return Math.Abs(Position) * (shortAvg - price);

		return 0m;
	}

	private int GetCurrentEntries()
	{
		if (Position > 0m)
		return _longEntries;

		if (Position < 0m)
		return _shortEntries;

		return 0;
	}

	private int GetEntryCountFromVolume(decimal volume)
	{
		if (volume <= 0m)
		return 0;

		if (OrderVolume <= 0m)
		return 1;

		var ratio = volume / OrderVolume;
		if (ratio <= 0m)
		return 0;

		var count = (int)Math.Round(ratio, MidpointRounding.AwayFromZero);
		return Math.Max(1, count);
	}

	private decimal GetPriceStep()
	{
		var step = Security?.PriceStep;
		return step is > 0m ? step.Value : 1m;
	}

	private bool IsWithinTradingWindow(DateTimeOffset time)
	{
		var start = StartHour;
		var end = EndHour;

		if (start < 0 || start > 23 || end < 0 || end > 23 || start >= end)
		{
			if (!_invalidHoursLogged)
			{
				LogWarning($"Invalid trading hours configuration. Start={start}, End={end}.");
				_invalidHoursLogged = true;
			}

			return false;
		}

		_invalidHoursLogged = false;

		var hour = time.Hour;
		return hour >= start && hour < end;
	}
}

import clr

clr.AddReference("StockSharp.Messages")
clr.AddReference("StockSharp.Algo")
clr.AddReference("StockSharp.Algo.Indicators")
clr.AddReference("StockSharp.Algo.Strategies")

import math
from System import TimeSpan
from StockSharp.Messages import DataType, CandleStates
from StockSharp.Algo.Indicators import SimpleMovingAverage
from StockSharp.Algo.Strategies import Strategy

class galactic_explosion_strategy(Strategy):
    """
    Galactic Explosion: grid strategy using MA bias with distance-based scaling.
    Buys when close < MA, sells when close > MA. After 8 entries applies
    indent and skip-candle logic for additional entries.
    """

    def __init__(self):
        super(galactic_explosion_strategy, self).__init__()
        self._start_hour = self.Param("StartHour", 8) \
            .SetDisplay("Start Hour", "Trading window start hour", "Time")
        self._end_hour = self.Param("EndHour", 20) \
            .SetDisplay("End Hour", "Trading window end hour", "Time")
        self._indent_after_eighth = self.Param("IndentAfterEighth", 100.0) \
            .SetDisplay("Indent After 8th", "Min distance after 8th entry (price steps)", "Grid")
        self._skip_three_candles_min = self.Param("SkipThreeCandlesMin", 300.0) \
            .SetDisplay("Skip3 Min", "Min distance for skip-3 logic", "Grid")
        self._skip_three_candles_max = self.Param("SkipThreeCandlesMax", 600.0) \
            .SetDisplay("Skip3 Max", "Max distance for skip-3 logic", "Grid")
        self._skip_six_candles_max = self.Param("SkipSixCandlesMax", 1200.0) \
            .SetDisplay("Skip6 Max", "Max distance for skip-6 logic", "Grid")
        self._ma_length = self.Param("MaLength", 14) \
            .SetDisplay("MA Length", "Moving average period", "Indicator")
        self._candle_type = self.Param("CandleType", DataType.TimeFrame(TimeSpan.FromMinutes(5))) \
            .SetDisplay("Candle Type", "Candle timeframe", "General")

        self._entries = 0
        self._first_price = 0.0
        self._last_price = 0.0
        self._missed_bars = 0

    @property
    def candle_type(self):
        return self._candle_type.Value

    def OnReseted(self):
        super(galactic_explosion_strategy, self).OnReseted()
        self._entries = 0
        self._first_price = 0.0
        self._last_price = 0.0
        self._missed_bars = 0

    def OnStarted2(self, time):
        super(galactic_explosion_strategy, self).OnStarted2(time)

        ma = SimpleMovingAverage()
        ma.Length = self._ma_length.Value

        subscription = self.SubscribeCandles(self.candle_type)
        subscription.Bind(ma, self._process_candle).Start()

    def _process_candle(self, candle, ma_value):
        if candle.State != CandleStates.Finished:
            return

        ma_val = float(ma_value)
        close = float(candle.ClosePrice)

        hour = candle.OpenTime.Hour
        if hour < self._start_hour.Value or hour >= self._end_hour.Value:
            return

        need_buy = close < ma_val
        need_sell = close > ma_val

        ps = 1.0
        if self.Security is not None and self.Security.PriceStep is not None:
            ps = float(self.Security.PriceStep)
        if ps <= 0:
            ps = 1.0

        if self._entries <= 8:
            if need_buy and self.Position <= 0:
                self._enter_long(close)
            elif need_sell and self.Position >= 0:
                self._enter_short(close)
            return

        indent = ps * self._indent_after_eighth.Value
        skip3_min = ps * self._skip_three_candles_min.Value
        skip3_max = ps * self._skip_three_candles_max.Value
        skip6_max = ps * self._skip_six_candles_max.Value

        if self.Position > 0:
            self._process_long_grid(close, need_buy, indent, skip3_min, skip3_max, skip6_max)
        elif self.Position < 0:
            self._process_short_grid(close, need_sell, indent, skip3_min, skip3_max, skip6_max)

    def _process_long_grid(self, price, need_buy, indent, skip3_min, skip3_max, skip6_max):
        if self._last_price <= 0 or self._first_price <= 0:
            return

        last_dist = abs(price - self._last_price)
        if last_dist <= indent:
            return

        first_dist = abs(price - self._first_price)

        if first_dist < skip3_min:
            self._missed_bars = 0
            if need_buy:
                self._enter_long(price)
        elif first_dist <= skip3_max:
            self._missed_bars += 1
            if self._missed_bars > 3:
                if need_buy:
                    self._enter_long(price)
                self._missed_bars = 0
        elif first_dist <= skip6_max:
            self._missed_bars += 1
            if self._missed_bars > 6:
                if need_buy:
                    self._enter_long(price)
                self._missed_bars = 0

    def _process_short_grid(self, price, need_sell, indent, skip3_min, skip3_max, skip6_max):
        if self._last_price <= 0 or self._first_price <= 0:
            return

        last_dist = abs(price - self._last_price)
        if last_dist <= indent:
            return

        first_dist = abs(price - self._first_price)

        if first_dist < skip3_min:
            self._missed_bars = 0
            if need_sell:
                self._enter_short(price)
        elif first_dist <= skip3_max:
            self._missed_bars += 1
            if self._missed_bars > 3:
                if need_sell:
                    self._enter_short(price)
                self._missed_bars = 0
        elif first_dist <= skip6_max:
            self._missed_bars += 1
            if self._missed_bars > 6:
                if need_sell:
                    self._enter_short(price)
                self._missed_bars = 0

    def _enter_long(self, price):
        if self._entries == 0:
            self._first_price = price
            self._missed_bars = 0
        self.BuyMarket()
        self._last_price = price
        self._entries += 1

    def _enter_short(self, price):
        if self._entries == 0:
            self._first_price = price
            self._missed_bars = 0
        self.SellMarket()
        self._last_price = price
        self._entries += 1

    def CreateClone(self):
        return galactic_explosion_strategy()