/// <summary>
/// logic close position
/// логика зыкрытия позиции и открытие по реверсивной системе
/// </summary>
private void LogicClosePosition(List <Candle> candles, Position position)
{
if (position.Direction == Side.Buy)
{
if (_lastBullsPrice + _lastBearsPrice < -Step.ValueDecimal)
{
_tab.CloseAtLimit(position, _lastPrice - Slippage.ValueInt * _tab.Securiti.PriceStep, position.OpenVolume);
if (Regime.ValueString != "OnlyLong" && Regime.ValueString != "OnlyClosePosition")
{
_tab.SellAtLimit(Volume.ValueDecimal, _lastPrice - Slippage.ValueInt * _tab.Securiti.PriceStep);
}
}
}
if (position.Direction == Side.Sell)
{
if (_lastBullsPrice + _lastBearsPrice > Step.ValueDecimal)
{
_tab.CloseAtLimit(position, _lastPrice + Slippage.ValueInt * _tab.Securiti.PriceStep, position.OpenVolume);
if (Regime.ValueString != "OnlyShort" && Regime.ValueString != "OnlyClosePosition")
{
_tab.BuyAtLimit(Volume.ValueDecimal, _lastPrice + Slippage.ValueInt * _tab.Securiti.PriceStep);
}
}
}
}
/// <summary>
/// logic close position
/// логика зыкрытия позиции и открытие по реверсивной системе
/// </summary>
private void LogicClosePosition(List <Candle> candles, Position position)
{
if (position.Direction == Side.Buy)
{
if (_lastWr > Upline.Value)
{
_tab.CloseAtLimit(position, _lastPrice - Slipage, position.OpenVolume);
if (Regime != BotTradeRegime.OnlyLong && Regime != BotTradeRegime.OnlyClosePosition)
{
_tab.SellAtLimit(VolumeFix, _lastPrice - Slipage);
}
}
}
if (position.Direction == Side.Sell)
{
if (_lastWr < Downline.Value)
{
_tab.CloseAtLimit(position, _lastPrice + Slipage, position.OpenVolume);
if (Regime != BotTradeRegime.OnlyShort && Regime != BotTradeRegime.OnlyClosePosition)
{
_tab.BuyAtLimit(VolumeFix, _lastPrice + Slipage);
}
}
}
}
/// <summary>
/// logic close position
/// логика зыкрытия позиции и открытие по реверсивной системе
/// </summary>
private void LogicClosePosition(List <Candle> candles, Position position)
{
if (position.Direction == Side.Buy)
{
if (_lastMacdUp < _lastMacdDown && _lastMom < 100)
{
_tab.CloseAtLimit(position, _lastClose - Slipage, position.OpenVolume);
if (Regime != BotTradeRegime.OnlyLong && Regime != BotTradeRegime.OnlyClosePosition)
{
_tab.SellAtLimit(VolumeFix, _lastClose - Slipage);
}
}
}
if (position.Direction == Side.Sell)
{
if (_lastMacdUp > _lastMacdDown && _lastMom > 100)
{
_tab.CloseAtLimit(position, _lastClose + Slipage, position.OpenVolume);
if (Regime != BotTradeRegime.OnlyShort && Regime != BotTradeRegime.OnlyClosePosition)
{
_tab.BuyAtLimit(VolumeFix, _lastClose + Slipage);
}
}
}
}
/// <summary>
/// logic close position
/// логика зыкрытия позиции и открытие по реверсивной системе
/// </summary>
private void LogicClosePosition(List <Candle> candles, Position position)
{
if (position.State == PositionStateType.Closing)
{
return;
}
if (position.Direction == Side.Buy)
{
if (_secondRsi >= Upline.Value && _firstRsi <= Upline.Value)
{
_tab.CloseAtLimit(position,
_lastPrice - Slippage.ValueInt * _tab.Securiti.PriceStep, position.OpenVolume);
if (Regime.ValueString != "OnlyLong" && Regime.ValueString != "OnlyClosePosition")
{
_tab.SellAtLimit(Volume.ValueDecimal,
_lastPrice - Slippage.ValueInt * _tab.Securiti.PriceStep);
}
}
}
if (position.Direction == Side.Sell)
{
if (_secondRsi <= Downline.Value && _firstRsi >= Downline.Value)
{
_tab.CloseAtLimit(position,
_lastPrice + Slippage.ValueInt * _tab.Securiti.PriceStep, position.OpenVolume);
if (Regime.ValueString != "OnlyShort" && Regime.ValueString != "OnlyClosePosition")
{
_tab.BuyAtLimit(Volume.ValueDecimal,
_lastPrice + Slippage.ValueInt * _tab.Securiti.PriceStep);
}
}
}
}
/// <summary>
/// logic close position
/// логика закрытия позиции
/// </summary>
private void LogicClosePosition(List <Candle> candles, Position openPosition)
{
if (openPosition.Direction == Side.Buy)
{
if (_lastPriceC > _pivotR3)
{
_tab.CloseAtLimit(openPosition, _lastPriceC - Slipage, openPosition.OpenVolume);
}
if (_lastPriceC < openPosition.EntryPrice - openPosition.EntryPrice / 100m * Stop)
{
_tab.CloseAtMarket(openPosition, openPosition.OpenVolume);
}
}
if (openPosition.Direction == Side.Sell)
{
if (_lastPriceC < _pivotS3)
{
_tab.CloseAtLimit(openPosition, _lastPriceC + Slipage, openPosition.OpenVolume);
}
if (_lastPriceC > openPosition.EntryPrice + openPosition.EntryPrice / 100m * Stop)
{
_tab.CloseAtMarket(openPosition, openPosition.OpenVolume);
}
}
}
/// <summary>
/// Закрытие позиции лонг (продажа)
/// </summary>
/// <param name="position">Позиция, которая будет закрыта</param>
private void CloseLong(Position position)
{
// получить цену из стакана, по которой можно продать весь объем для закрытия позиции лонг
decimal volumePosition = position.OpenVolume;
decimal pricePosition = GetPriceSell(volumePosition);
// если цена выхода из позиции посчиталась правильно, тогда выход из позиции по лимиту
if (pricePosition > 0)
{
// из цены выхода из позиции вычитаем проскальзывание (продаем дешевле)
decimal priceClosePosition = pricePosition - Slippage.ValueInt * _tab.Securiti.PriceStep;
// выход из позиции лонг по лимиту
_tab.CloseAtLimit(position, priceClosePosition, volumePosition);
if (OnDebug.ValueBool)
{
_tab.SetNewLogMessage($"Отладка. Закрытие лонга по лимиту: объем - {volumePosition}, цена - {pricePosition}, цена с проск.- {priceClosePosition}.", Logging.LogMessageType.User);
}
}
// если цена выхода не посчиталась, тогда выход из позиции лонг по маркету
else
{
_tab.CloseAtMarket(position, volumePosition);
_tab.SetNewLogMessage($"CloseLong: Некорректная цена выхода. Закрытие лонга по маркету: объем - {volumePosition}.", Logging.LogMessageType.Error);
}
return;
}
/// <summary>
/// логика закрытия позиции
/// </summary>
private void LogicClosePosition(Position position, List <Candle> candles)
{
if (position.State == PositionStateType.Closing)
{
return;
}
decimal moving = _moving.Values[_moving.Values.Count - 1];
decimal lastClose = candles[candles.Count - 1].Close;
if (position.Direction == Side.Buy)
{
if (lastClose > moving)
{
_tab.CloseAtLimit(position, lastClose - Slipage, position.OpenVolume);
}
}
if (position.Direction == Side.Sell)
{
if (lastClose < moving)
{
_tab.CloseAtLimit(position, lastClose + Slipage, position.OpenVolume);
}
}
}
/// <summary>
/// logic close position
/// логика зыкрытия позиции
/// </summary>
private void LogicClosePosition(List <Candle> candles, Position position)
{
if (position.Direction == Side.Buy && position.State == PositionStateType.Open)
{
if (_lastRviDown > 0 && _lastRviUp < _lastRviDown)
{
_tab.CloseAtLimit(position, _lastPrice - Slippage.ValueInt, position.OpenVolume);
if (Regime.ValueString != "OnlyLong" && Regime.ValueString != "OnlyClosePosition")
{
_tab.SellAtLimit(Volume.ValueDecimal, _lastPrice - Slippage.ValueInt * _tab.Securiti.PriceStep);
}
}
}
if (position.Direction == Side.Sell && position.State == PositionStateType.Open)
{
if (_lastRviDown < 0 && _lastRviUp > _lastRviDown)
{
_tab.CloseAtLimit(position, _lastPrice + Slippage.ValueInt, position.OpenVolume);
if (Regime.ValueString != "OnlyShort" && Regime.ValueString != "OnlyClosePosition")
{
_tab.BuyAtLimit(Volume.ValueDecimal, _lastPrice + Slippage.ValueInt * _tab.Securiti.PriceStep);
}
}
}
}
/// <summary>
/// logic close position
/// логика зыкрытия позиции и открытие по реверсивной системе
/// </summary>
private void LogicClosePosition(List <Candle> candles, Position position)
{
if (position.Direction == Side.Buy)
{
if (_lastClose <= _lastLow + ((_lastHigh - _lastLow) / 3) && _lastOpen <= _lastLow + ((_lastHigh - _lastLow) / 3) &&
_lastSma > _lastClose)
{
_tab.CloseAtLimit(position, _lastClose - Slipage, position.OpenVolume);
if (Regime != BotTradeRegime.OnlyLong && Regime != BotTradeRegime.OnlyClosePosition)
{
_tab.SellAtLimit(VolumeFix, _lastClose - Slipage);
}
}
}
if (position.Direction == Side.Sell)
{
if (_lastClose >= _lastHigh - ((_lastHigh - _lastLow) / 3) && _lastOpen >= _lastHigh - ((_lastHigh - _lastLow) / 3) &&
_lastSma < _lastClose)
{
_tab.CloseAtLimit(position, _lastClose + Slipage, position.OpenVolume);
if (Regime != BotTradeRegime.OnlyShort && Regime != BotTradeRegime.OnlyClosePosition)
{
_tab.BuyAtLimit(VolumeFix, _lastClose + Slipage);
}
}
}
}
/// <summary>
/// check exit from position
/// проверить выходы из позиций
/// </summary>
private void CheckExit()
{
List <Position> positions = _tab1.PositionsOpenAll;
if (positions == null || positions.Count == 0)
{
return;
}
decimal smaShortNow = _smaShort.Values[_smaShort.Values.Count - 1];
decimal smaShortLast = _smaShort.Values[_smaShort.Values.Count - 2];
decimal smaLong = _smaLong.Values[_smaLong.Values.Count - 1];
decimal smaLongLast = _smaLong.Values[_smaLong.Values.Count - 1];
if (smaShortNow == 0 || smaLong == 0 ||
smaShortLast == 0 || smaLongLast == 0)
{
return;
}
if (smaShortLast < smaLongLast &&
smaShortNow > smaLong)
{
List <Position> positions1 = _tab1.PositionOpenLong;
List <Position> positions2 = _tab2.PositionOpenShort;
if (positions1 != null && positions1.Count != 0)
{
Position pos1 = positions1[0];
_tab1.CloseAtLimit(pos1, _tab1.PriceBestBid - Slipage1, pos1.OpenVolume);
}
if (positions2 != null && positions2.Count != 0)
{
Position pos2 = positions2[0];
_tab2.CloseAtLimit(pos2, _tab2.PriceBestAsk + Slipage1, pos2.OpenVolume);
}
}
if (smaShortLast > smaLongLast &&
smaShortNow < smaLong)
{
List <Position> positions1 = _tab1.PositionOpenShort;
List <Position> positions2 = _tab2.PositionOpenLong;
if (positions1 != null && positions1.Count != 0)
{
Position pos1 = positions1[0];
_tab1.CloseAtLimit(pos1, _tab1.PriceBestAsk + Slipage1, pos1.OpenVolume);
}
if (positions2 != null && positions2.Count != 0)
{
Position pos2 = positions2[0];
_tab2.CloseAtLimit(pos2, _tab2.PriceBestBid - Slipage1, pos2.OpenVolume);
}
}
}
/// <summary>
/// Закрытие позиции лонг (продажа)
/// </summary>
/// <param name="position">Позиция, которая будет закрыта</param>
private void CloseLong(Position position)
{
decimal volumePosition = position.OpenVolume;
// цена выхода из позиции (продаем дешевле)
decimal priceClosePosition = _tab.PriceBestBid - Slippage.ValueInt * _tab.Securiti.PriceStep;
// выход из позиции лонг по лимиту
_tab.CloseAtLimit(position, priceClosePosition, volumePosition);
}
private void CloseShort(Position shortPosition)
{
// если позиция уже закрывается, то ничего не делаем
if (shortPosition.CloseActiv)
{
return;
}
// выставляем лимитную заявку на закрытие позиции шорт (покупаем)
_tabSec.CloseAtLimit(shortPosition,
_tabSec.PriceBestAsk + Slippage * _tabSec.Securiti.PriceStep,
shortPosition.OpenVolume);
}
private void CloseAllPositions()
{
List <Position> openPositions = _tab.PositionsOpenAll;
Position[] poses = openPositions.ToArray();
decimal lastBestBuy = _tab.PriceBestBid;
decimal lastBestSell = _tab.PriceBestAsk;
for (int i = 0; poses != null && i < poses.Length; i++)
{
if (poses[i].State == PositionStateType.Open ||
poses[i].State == PositionStateType.ClosingFail)
{
if (poses[i].CloseActiv)
{
continue;
}
if (poses[i].Direction == Side.Buy)
{
decimal price = lastBestSell;
decimal priceToPercent =
poses[i].EntryPrice + poses[i].EntryPrice * (PersentFromBorder.ValueDecimal / 100 / 2);
if ((poses[i].CloseOrders == null ||
poses[i].CloseOrders.Count < 3) &&
priceToPercent > price)
{
price = priceToPercent;
}
_tab.CloseAtLimit(poses[i], price, poses[i].OpenVolume);
}
if (poses[i].Direction == Side.Sell)
{
decimal price = lastBestBuy;
decimal priceToPercent = poses[i].EntryPrice - poses[i].EntryPrice * (PersentFromBorder.ValueDecimal / 100 / 2);
if ((poses[i].CloseOrders == null ||
poses[i].CloseOrders.Count < 3) &&
priceToPercent < price)
{
price = priceToPercent;
}
_tab.CloseAtLimit(poses[i], price, poses[i].OpenVolume);
}
}
}
Thread.Sleep(200);
}
private void _tab_PositionOpeningSuccesEvent(Position obj)
{
if (
(obj.Direction == Side.Buy && LastStop > obj.EntryPrice) ||
(obj.Direction == Side.Sell && LastStop < obj.EntryPrice) ||
LastStop == 0
)
{
LastStop = GetStopLevel(obj.Direction, obj.EntryPrice);
}
//выставим новые стопы
_tab.CloseAtServerTrailingStop(obj, LastStop, LastStop);
if (NeadStepOpen)
{
OpenStepLimit(obj);
}
// _tab.CloseAtProfit(obj, 2*(obj.EntryPrice - LastStop)+ obj.EntryPrice, 2 * (obj.EntryPrice - LastStop) + obj.EntryPrice);
//_tab.CloseAtTrailingStop(obj, LastStop, LastStop);
if (UseSafe.ValueBool)
{
decimal fixPOs = 2 * obj.EntryPrice - LastStop;
decimal vol = obj.OpenVolume / 2;
if (isContract.ValueBool)
{
vol = (int)vol;
}
_tab.CloseAtLimit(obj, fixPOs, vol);
}
if (Breakeven.ValueBool)
{
NeedBreakeven = true;
}
}
/// <summary>
/// logic close position
/// логика зыкрытия позиции и открытие по реверсивной системе
/// </summary>
private void LogicClosePosition(Position position, BotTabSimple tab, decimal lastRsi)
{
if (position.Direction == Side.Buy)
{
if (lastRsi > Upline.ValueInt)
{
tab.CloseAtLimit(position, tab.PriceBestBid - Slippage.ValueInt * tab.Securiti.PriceStep, position.OpenVolume);
}
}
if (position.Direction == Side.Sell)
{
if (lastRsi < Downline.ValueInt)
{
tab.CloseAtLimit(position, tab.PriceBestAsk + Slippage.ValueInt * tab.Securiti.PriceStep, position.OpenVolume);
}
}
}
/// <summary>
/// logic close position
/// логика зыкрытия позиции и открытие по реверсивной системе
/// </summary>
private void LogicClosePosition(List <Candle> candles, Position position)
{
if (position.Direction == Side.Buy)
{
if (_stocLastDown > Upline.Value && _stocLastDown < _stocLastUp)
{
_tab.CloseAtLimit(
position,
_lastPrice - Slippage.ValueInt * _tab.Securiti.PriceStep,
position.OpenVolume);
if (Regime.ValueString != "OnlyLong" && Regime.ValueString != "OnlyClosePosition")
{
List <Position> positions = _tab.PositionsOpenAll;
if (positions.Count >= 2)
{
return;
}
_tab.SellAtLimit(Volume.ValueDecimal, _lastPrice - Slippage.ValueInt * _tab.Securiti.PriceStep);
}
}
}
if (position.Direction == Side.Sell)
{
if (_stocLastDown < Downline.Value && _stocLastDown > _stocLastUp)
{
_tab.CloseAtLimit(
position,
_lastPrice + Slippage.ValueInt * _tab.Securiti.PriceStep,
position.OpenVolume);
if (Regime.ValueString != "OnlyShort" && Regime.ValueString != "OnlyClosePosition")
{
List <Position> positions = _tab.PositionsOpenAll;
if (positions.Count >= 2)
{
return;
}
_tab.BuyAtLimit(Volume.ValueDecimal, _lastPrice + Slippage.ValueInt * _tab.Securiti.PriceStep);
}
}
}
}
/// <summary>
/// logic close position
/// логика зыкрытия позиции
/// </summary>
private void LogicClosePosition(List <Candle> candles, Position position)
{
if (position.Direction == Side.Buy)
{
if (_lastClose < _lastSma - Step)
{
_tab.CloseAtLimit(position, _lastClose - Slipage, position.OpenVolume);
}
}
if (position.Direction == Side.Sell)
{
if (_lastClose > _lastSma + Step)
{
_tab.CloseAtLimit(position, _lastClose - Slipage, position.OpenVolume);
}
}
}
private void TryCloseShortPositions()
{
// получаем все позиции шорт
List <Position> positions = _tab.PositionOpenShort;
for (int i = 0; i < positions.Count; i++)
{
// если позиция уже закрывается, то ничего не делаем
if (positions[i].CloseActiv)
{
continue;
}
// выставляем лимитную заявку на закрытие позиции шорт (покупаем)
// дополнительно добавил проскальзывание
_tab.CloseAtLimit(positions[i],
_tab.PriceBestAsk + Slippage * _tab.Securiti.PriceStep,
positions[i].OpenVolume);
}
}
/// <summary>
/// logic close position
/// логика зыкрытия позиции и открытие по реверсивной системе
/// </summary>
private void LogicClosePosition(List <Candle> candles, Position position)
{
decimal lastClose = candles[candles.Count - 1].Close;
if (position.Direction == Side.Buy)
{
if (lastClose < _lastMa || _lastRsi > Upline.Value)
{
_tab.CloseAtLimit(position, _lastPrice - Slipage, position.OpenVolume);
}
}
if (position.Direction == Side.Sell)
{
if (lastClose > _lastMa || _lastRsi < Downline.Value)
{
_tab.CloseAtLimit(position, _lastPrice + Slipage, position.OpenVolume);
}
}
}
/// <summary>
/// logic close position
/// логика зыкрытия позиции и открытие по реверсивной системе
/// </summary>
private void LogicClosePosition(List <Candle> candles, Position position)
{
if (position.State == PositionStateType.Closing ||
position.CloseActiv == true ||
(position.CloseOrders != null && position.CloseOrders.Count > 0))
{
return;
}
if (position.Direction == Side.Buy)
{
if (_lastPrice < _bolLastDown)
{
_tab.CloseAtLimit(
position,
_lastPrice - Slippage.ValueInt * _tab.Securiti.PriceStep,
position.OpenVolume);
if (Regime.ValueString != "OnlyLong" &&
Regime.ValueString != "OnlyClosePosition")
{
_tab.SellAtLimit(Volume.ValueDecimal, _lastPrice - Slippage.ValueInt * _tab.Securiti.PriceStep);
}
}
}
if (position.Direction == Side.Sell)
{
if (_lastPrice > _bolLastUp)
{
_tab.CloseAtLimit(
position,
_lastPrice + Slippage.ValueInt * _tab.Securiti.PriceStep,
position.OpenVolume);
if (Regime.ValueString != "OnlyShort" &&
Regime.ValueString != "OnlyClosePosition")
{
_tab.BuyAtLimit(Volume.ValueDecimal, _lastPrice + Slippage.ValueInt * _tab.Securiti.PriceStep);
}
}
}
}
/// <summary>
/// close position logic
/// логика закрытия позиции
/// </summary>
private void LogicClosePosition(Position position, List <Candle> candles)
{
if (position.State != PositionStateType.Open)
{
return;
}
if (position.Direction == Side.Buy)
{
if (_lastPrice < _lastMiddleAlligator)
{
_tab.CloseAtLimit(position, _lastPrice - Slippage.ValueInt * _tab.Securiti.PriceStep, position.OpenVolume);
}
}
if (position.Direction == Side.Sell)
{
if (_lastPrice > _lastMiddleAlligator)
{
_tab.CloseAtLimit(position, _lastPrice + Slippage.ValueInt * _tab.Securiti.PriceStep, position.OpenVolume);
}
}
}
/// <summary>
/// logic close position
/// логика зыкрытия позиции и открытие по реверсивной системе
/// </summary>
private void LogicClosePosition(List <Candle> candles, Position position)
{
if (position.State != PositionStateType.Open)
{
return;
}
if (position.Direction == Side.Buy)
{
if (_lastPriceL < _lastPriceChDown)
{
_tab.CloseAtLimit(position, _lastPriceC - Slipage, position.OpenVolume);
if (Regime != BotTradeRegime.OnlyLong &&
Regime != BotTradeRegime.OnlyClosePosition &&
_tab.PositionsOpenAll.Count < 3)
{
_tab.SellAtLimit(VolumeFix, _lastPriceC - Slipage);
}
}
}
if (position.Direction == Side.Sell)
{
if (_lastPriceH > _lastPriceChUp)
{
_tab.CloseAtLimit(position, _lastPriceC + Slipage, position.OpenVolume);
if (Regime != BotTradeRegime.OnlyShort && Regime
!= BotTradeRegime.OnlyClosePosition &&
_tab.PositionsOpenAll.Count < 3)
{
_tab.BuyAtLimit(VolumeFix, _lastPriceC + Slipage);
}
}
}
}
/// <summary>
/// logic close position
/// логика зыкрытия позиции и открытие по реверсивной системе
/// </summary>
private void LogicClosePosition(List <Candle> candles, Position position)
{
if (position.State != PositionStateType.Open ||
position.CloseActiv == true ||
(position.CloseOrders != null && position.CloseOrders.Count > 0))
{
return;
}
if (position.Direction == Side.Buy)
{
if (_lastClose <= _lastLow + ((_lastHigh - _lastLow) / 3) && _lastOpen <= _lastLow + ((_lastHigh - _lastLow) / 3) &&
_lastSma > _lastClose)
{
_tab.CloseAtLimit(position, _lastClose - Slipage, position.OpenVolume);
if (Regime == BotTradeRegime.On) // Fix: Открываем реверсивную сделку только если торгуем и в лонг и в шорт
{
_tab.SellAtLimit(VolumeFix, _lastClose - Slipage);
}
}
}
else if (position.Direction == Side.Sell)
{
if (_lastClose >= _lastHigh - ((_lastHigh - _lastLow) / 3) && _lastOpen >= _lastHigh - ((_lastHigh - _lastLow) / 3) &&
_lastSma < _lastClose)
{
_tab.CloseAtLimit(position, _lastClose + Slipage, position.OpenVolume);
if (Regime == BotTradeRegime.On) // Fix: Открываем реверсивную сделку только если торгуем и в лонг и в шорт
{
_tab.BuyAtLimit(VolumeFix, _lastClose + Slipage);
}
}
}
}
/// <summary>
/// logic close position
/// логика зыкрытия позиции и открытие по реверсивной системе
/// </summary>
private void LogicClosePosition(List <Candle> candles, Position position)
{
if (position.State != PositionStateType.Open ||
position.CloseActiv == true ||
(position.CloseOrders != null && position.CloseOrders.Count > 0))
{
return;
}
if (position.Direction == Side.Buy)
{
if (_lastClose <= _lastLow + ((_lastHigh - _lastLow) / 3) && _lastOpen <= _lastLow + ((_lastHigh - _lastLow) / 3) &&
_lastSma > _lastClose)
{
_tab.CloseAtLimit(position, _lastClose - Slipage, position.OpenVolume);
if (Regime != BotTradeRegime.OnlyLong && Regime != BotTradeRegime.OnlyClosePosition)
{
_tab.SellAtLimit(VolumeFix, _lastClose - Slipage);
}
}
}
else if (position.Direction == Side.Sell)
{
if (_lastClose >= _lastHigh - ((_lastHigh - _lastLow) / 3) && _lastOpen >= _lastHigh - ((_lastHigh - _lastLow) / 3) &&
_lastSma < _lastClose)
{
_tab.CloseAtLimit(position, _lastClose + Slipage, position.OpenVolume);
if (Regime != BotTradeRegime.OnlyLong && Regime != BotTradeRegime.OnlyClosePosition)
{
_tab.BuyAtLimit(VolumeFix, _lastClose + Slipage);
}
}
}
}
/// <summary>
/// logic close position
/// логика зыкрытия позиции и открытие по реверсивной системе
/// </summary>
private void LogicClosePosition(List <Candle> candles, Position position, List <Position> allPos)
{
if (position.State != PositionStateType.Open)
{
return;
}
if (position.Direction == Side.Buy)
{
if (_lastCci > Upline.Value)
{
_tab.CloseAtLimit(position, _lastPrice - Slippage.ValueInt * _tab.Securiti.PriceStep, position.OpenVolume);
if (Regime.ValueString != "OnlyLong" &&
Regime.ValueString != "OnlyClosePosition" &&
allPos.Count < 3)
{
_tab.SellAtLimit(Volume.ValueDecimal, _lastPrice - Slippage.ValueInt * _tab.Securiti.PriceStep);
}
}
}
if (position.Direction == Side.Sell)
{
if (_lastCci < Downline.Value)
{
_tab.CloseAtLimit(position, _lastPrice + Slippage.ValueInt * _tab.Securiti.PriceStep, position.OpenVolume);
if (Regime.ValueString != "OnlyShort" &&
Regime.ValueString != "OnlyClosePosition" &&
allPos.Count < 3)
{
_tab.BuyAtLimit(Volume.ValueDecimal, _lastPrice + Slippage.ValueInt * _tab.Securiti.PriceStep);
}
}
}
}
/// <summary>
/// ошибка с закрытием заявки
/// </summary>
void _tab_PositionClosingFailEvent(Position position)
{
if (position.OpenVolume > 0)
{
position.State = PositionStateType.Open;
}
if (position.OpenVolume < 0)
{
position.State = PositionStateType.ClosingSurplus;
}
if (StartProgram == StartProgram.IsTester)
{
return;
}
if (_positionToClose != null && _positionToClose.Number == position.Number)
{
return;
}
if (position.OpenVolume == 0)
{
return;
}
if (position.CloseOrders.Count > 1)
{
return;
}
if (position.Direction == Side.Buy)
{
decimal price = _tab.PriceBestAsk - SlipageCloseSecond * _tab.Securiti.PriceStep;
_tab.CloseAtLimit(position, price, position.OpenVolume);
}
else if (position.Direction == Side.Sell)
{
decimal price = _tab.PriceBestBid + SlipageCloseSecond * _tab.Securiti.PriceStep;
_tab.CloseAtLimit(position, price, position.OpenVolume);
}
}
/// <summary>
/// close position
/// закрываем позицию по номеру
/// </summary>
private void NeadToClose(int positionNum)
{
Position pos;
pos = _tab1.PositionsOpenAll.Find(position => position.Number == positionNum);
if (pos != null)
{
decimal price;
if (pos.Direction == Side.Buy)
{
price = _tab1.CandlesAll[_tab1.CandlesAll.Count - 1].Close - _tab1.Securiti.PriceStep * 10;
}
else
{
price = _tab1.CandlesAll[_tab1.CandlesAll.Count - 1].Close + _tab1.Securiti.PriceStep * 10;
}
_tab1.CloseAtLimit(pos, price, pos.OpenVolume);
return;
}
pos = _tab2.PositionsOpenAll.Find(position => position.Number == positionNum);
if (pos != null)
{
decimal price;
if (pos.Direction == Side.Buy)
{
price = _tab2.CandlesAll[_tab2.CandlesAll.Count - 1].Close - _tab2.Securiti.PriceStep * 10;
}
else
{
price = _tab2.CandlesAll[_tab2.CandlesAll.Count - 1].Close + _tab2.Securiti.PriceStep * 10;
}
_tab2.CloseAtLimit(pos, price, pos.OpenVolume);
}
}
public void TryEmergencyClosePosition(BotTabSimple bot, Position position)
{
if (TypeDoubleExitOrder == OrderPriceType.Market)
{
bot.CloseAtMarket(position, position.OpenVolume);
}
else if (TypeDoubleExitOrder == OrderPriceType.Limit)
{
decimal price;
if (position.Direction == Side.Buy)
{
price = bot.PriceBestBid - GetEmergencyExitDistance(bot, position);
}
else
{
price = bot.PriceBestAsk + GetEmergencyExitDistance(bot, position);
}
bot.CloseAtLimit(position, price, position.OpenVolume);
}
}
/// <summary>
/// событие завершения свечи
/// </summary>
void _tab_CandleFinishedEvent(List <Candle> candles)
{
if (Regime == BotTradeRegime.Off)
{
return;
}
List <Position> positions = _tab.PositionsOpenAll;
if (positions.Count < MaxPosition)
{
if (CheckInter(PatternsToOpen, candles, candles.Count - 1, WeigthToInter))
{
InterInNewPosition(candles[candles.Count - 1].Close);
}
}
for (int i = 0; i < positions.Count; i++)
{
if (positions[i].State != PositionStateType.Open)
{
continue;
}
decimal priceExit;
priceExit = CheckExit(positions[i], PatternsToClose, candles, candles.Count - 1, candles[candles.Count - 1].Close);
if (priceExit == 0)
{
continue;
}
_tab.CloseAtLimit(positions[i], priceExit, positions[i].OpenVolume);
}
}
/// <summary>
/// Логика закрытия позиций
/// </summary>
/// <param name="candles">Свечи индекса</param>
/// <param name="positions1">Открытые позиции по инструменту 1</param>
/// <param name="positions2">Открытые позиции по инструменту 2</param>
private void LogicToClose(List <Position> positions1, List <Position> positions2)
{
// если позиции по инструментам не в состоянии Open, то ничего не делаем
// Проблема. Если по какой-то причине открылись только одной ногой, то при этом условии мы никогда не закроемся.
/*
* if (positions1.Count != 0 && positions1[0].State != PositionStateType.Open ||
* positions2.Count != 0 && positions2[0].State != PositionStateType.Open)
* {
* return;
* }
*/
// закрытие позиций, которые открылись, когда индекс (спред) был ниже канала
if (_lastIndex > _lastMA + _lastIvashov * Multiply.ValueDecimal)
{
if (positions1.Count != 0 &&
positions1[0].State == PositionStateType.Open &&
positions1[0].Direction != Side1)
{
if (positions1[0].Direction == Side.Buy)
{
_tab1.CloseAtLimit(positions1[0],
_tab1.PriceBestBid - Slippage1 * _tab1.Securiti.PriceStep,
positions1[0].OpenVolume);
}
else if (positions1[0].Direction == Side.Sell)
{
_tab1.CloseAtLimit(positions1[0],
_tab1.PriceBestAsk + Slippage1 * _tab1.Securiti.PriceStep,
positions1[0].OpenVolume);
}
}
if (positions2.Count != 0 &&
positions2[0].State == PositionStateType.Open &&
positions2[0].Direction != Side2)
{
if (positions2[0].Direction == Side.Buy)
{
_tab2.CloseAtLimit(positions2[0],
_tab2.PriceBestBid - Slippage2 * _tab2.Securiti.PriceStep,
positions2[0].OpenVolume);
}
else if (positions2[0].Direction == Side.Sell)
{
_tab2.CloseAtLimit(positions2[0],
_tab2.PriceBestAsk + Slippage2 * _tab2.Securiti.PriceStep,
positions2[0].OpenVolume);
}
}
}
// закрытие позиций, которые открылись, когда индекс (спред) был выше канала
else if (_lastIndex < _lastMA - _lastIvashov * Multiply.ValueDecimal)
{
if (positions1.Count != 0 &&
positions1[0].State == PositionStateType.Open &&
positions1[0].Direction == Side1)
{
if (positions1[0].Direction == Side.Buy)
{
_tab1.CloseAtLimit(positions1[0],
_tab1.PriceBestBid - Slippage1 * _tab1.Securiti.PriceStep,
positions1[0].OpenVolume);
}
else if (positions1[0].Direction == Side.Sell)
{
_tab1.CloseAtLimit(positions1[0],
_tab1.PriceBestAsk + Slippage1 * _tab1.Securiti.PriceStep,
positions1[0].OpenVolume);
}
}
if (positions2.Count != 0 &&
positions2[0].State == PositionStateType.Open &&
positions2[0].Direction == Side2)
{
if (positions2[0].Direction == Side.Buy)
{
_tab2.CloseAtLimit(positions2[0],
_tab2.PriceBestBid - Slippage2 * _tab2.Securiti.PriceStep,
positions2[0].OpenVolume);
}
else if (positions2[0].Direction == Side.Sell)
{
_tab2.CloseAtLimit(positions2[0],
_tab2.PriceBestAsk + Slippage2 * _tab2.Securiti.PriceStep,
positions2[0].OpenVolume);
}
}
}
}
