I need help with robot

I want that this robot waiting for the opening the first position in hand.

this can be done?

// -------------------------------------------------------------------------------
//
//    This is a Template used as a guideline to build your own Robot. 
//    Please use the “Feedback” tab to provide us with your suggestions about cAlgo’s API.
//
// -------------------------------------------------------------------------------

using System;
using cAlgo.API;
//using cAlgo.API.Indicators;

namespace cAlgo.Robots
{
    [Robot("The Ilan Dynamic Robot")]
    public class IlanDynamic : Robot
    {
        [Parameter(DefaultValue = 10000, MinValue = 1000)]
        public int StartVolume { get; set; }

        [Parameter(DefaultValue = 10000, MinValue = 1000)]
        public int LotStep { get; set; }

		[Parameter("Take Profit (pips)", DefaultValue = 200, MinValue = 10)]
        public int TakeProfit { get; set; }

		[Parameter(DefaultValue = 1.6, MinValue = 1)]
        public double VolumeExponent { get; set; }

		[Parameter(DefaultValue = 0)]
        public int PipStep { get; set; }

		[Parameter(DefaultValue = 4, MinValue = 2)]
        public int MaxStepCount { get; set; }
        
        private Position position;
		private bool RobotStopped;
		
        protected override void OnStart()
        {
            
        }

        protected override void OnTick()
        {
        	if(Trade.IsExecuting) return;
        	if(Account.Positions.Count > 0 && RobotStopped) return;
        	else RobotStopped = false;

        	if(Account.Positions.Count == 0) 
        		SendFirstOrder(StartVolume);
        	else
        		ControlSeries();
        }

        protected override void OnError(Error CodeOfError)
        {
            if(CodeOfError.Code == ErrorCode.NoMoney)
            {
            	RobotStopped = true;
            	Print("ERROR!!! No money for order open, robot is stopped!");
            }
            else if(CodeOfError.Code == ErrorCode.BadVolume)
            {
            	RobotStopped = true;
            	Print("ERROR!!! Bad volume for order open, robot is stopped!");
            }
        }
        
        private void SendFirstOrder(int OrderVolume)
        {
        	int Signal = GetStdIlanSignal();
        	if(!(Signal < 0))
        		switch(Signal)
        		{
        			case 0:
        				Trade.CreateBuyMarketOrder(Symbol, OrderVolume);
        			break;
        			case 1:
        				Trade.CreateSellMarketOrder(Symbol, OrderVolume);
        			break;
        		}
        }
        
        protected override void OnPositionOpened(Position openedPosition)
        {
			double? StopLossPrice = null;
            double? TakeProfitPrice = null;
			
			if(Account.Positions.Count == 1)
			{
				position = openedPosition;
				if( position.TradeType == TradeType.Buy)
		        	TakeProfitPrice = position.EntryPrice + TakeProfit * Symbol.PointSize;
				if( position.TradeType == TradeType.Sell)
	                TakeProfitPrice = position.EntryPrice - TakeProfit * Symbol.PointSize;
			}
			else
                switch(GetPositionsSide())
                {
                	case 0:
		                TakeProfitPrice = GetAveragePrice(TradeType.Buy) + TakeProfit * Symbol.PointSize;
                	break;
                	case 1:
		                TakeProfitPrice = GetAveragePrice(TradeType.Sell) - TakeProfit * Symbol.PointSize;
                	break;
                }

			for(int i = 0; i < Account.Positions.Count; i++)
        	{
				position = Account.Positions[i];
				if(StopLossPrice != null || TakeProfitPrice != null)
					Trade.ModifyPosition(position, StopLossPrice, TakeProfitPrice);
			}
        }

        private double GetAveragePrice(TradeType TypeOfTrade)
        {
        	double Result = Symbol.Bid;
			double AveragePrice = 0;
  			long Count = 0;

			for(int i = 0; i < Account.Positions.Count; i++)
			{
				position = Account.Positions[i];
				if(position.TradeType == TypeOfTrade)
   				{
   					AveragePrice += position.EntryPrice * position.Volume;
   					Count += position.Volume;
   				}
   			}
  			if(AveragePrice > 0 && Count > 0)
    			Result = AveragePrice / Count;
        	return Result;
        }

        private int GetPositionsSide()
        {
        	int Result = -1;
        	int i, BuySide = 0, SellSide = 0;
        	
        	for(i = 0; i < Account.Positions.Count; i++)
        	{
        		if(Account.Positions[i].TradeType == TradeType.Buy) BuySide++;
        		if(Account.Positions[i].TradeType == TradeType.Sell) SellSide++;
        	}
        	if(BuySide == Account.Positions.Count) Result = 0;
        	if(SellSide == Account.Positions.Count) Result = 1;
        	return Result;
        }
        
        private void ControlSeries()
        {
        	int _pipstep, NewVolume, Rem;
        	int BarCount = 25;
        	int Del = MaxStepCount - 1;
        	
        	if(PipStep == 0)
        		_pipstep = GetDynamicPipstep(BarCount, Del);
        	else
        		_pipstep = PipStep;
        	
            if(Account.Positions.Count < MaxStepCount)
	            switch(GetPositionsSide())
    	        {
    	          	case 0:
			        	if(Symbol.Ask < FindLastPrice(TradeType.Buy) - _pipstep * Symbol.PointSize)
			        	{
			        		NewVolume = Math.DivRem((int)(StartVolume * Math.Pow(VolumeExponent, Account.Positions.Count)), LotStep, out Rem) * LotStep;
    	    				if(!(NewVolume < LotStep))
	    	    				Trade.CreateBuyMarketOrder(Symbol, NewVolume);
			        	}
    	           	break;
    	           	case 1:
			        	if(Symbol.Bid > FindLastPrice(TradeType.Sell) + _pipstep * Symbol.PointSize)
			        	{
			        		NewVolume = Math.DivRem((int)(StartVolume * Math.Pow(VolumeExponent, Account.Positions.Count)), LotStep, out Rem) * LotStep;
    	    				if(!(NewVolume < LotStep))
    	    					Trade.CreateSellMarketOrder(Symbol, NewVolume);
			        	}
    	           	break;
    	        }
        }
        
        private int GetDynamicPipstep(int CountOfBars, int Del)
        {
        	int Result;
        	double HighestPrice = 0, LowestPrice = 0;
        	int StartBar = MarketSeries.Close.Count - 2 - CountOfBars;
        	int EndBar = MarketSeries.Close.Count - 2;
        	
        	for(int i = StartBar; i < EndBar; i++)
        	{
        		if(HighestPrice == 0 && LowestPrice == 0)
				{        		
        			HighestPrice = MarketSeries.High[i];
        			LowestPrice = MarketSeries.Low[i];
        			continue;
        		}
        		if(MarketSeries.High[i] > HighestPrice) HighestPrice = MarketSeries.High[i];
        		if(MarketSeries.Low[i] < LowestPrice) LowestPrice = MarketSeries.Low[i];
        	}
        	Result = (int)((HighestPrice - LowestPrice) / Symbol.PointSize / Del);
        	return Result;
        }
        
        private double FindLastPrice(TradeType TypeOfTrade)
        {
			double LastPrice = 0;

			for(int i = 0; i < Account.Positions.Count; i++) 
			{
		        position = Account.Positions[i];
		        if(TypeOfTrade == TradeType.Buy)
		        	if(position.TradeType == TypeOfTrade) 
          			{
	           			if(LastPrice == 0)
	           			{
	           				LastPrice = position.EntryPrice;
	           				continue;
	           			}
            			if(position.EntryPrice < LastPrice)
              				LastPrice = position.EntryPrice;
          			}
		        if(TypeOfTrade == TradeType.Sell)
		        	if(position.TradeType == TypeOfTrade) 
          			{
	           			if(LastPrice == 0)
	           			{
	           				LastPrice = position.EntryPrice;
	           				continue;
	           			}
            			if(position.EntryPrice > LastPrice)
              				LastPrice = position.EntryPrice;
          			}
          	}
          	return LastPrice;
        }
        
        private int GetStdIlanSignal()
        {
        	int Result = -1;
        	int LastBarIndex = MarketSeries.Close.Count - 2;
        	int PrevBarIndex = LastBarIndex - 1;
        	
        	if(MarketSeries.Close[LastBarIndex] > MarketSeries.Open[LastBarIndex])
				if(MarketSeries.Close[PrevBarIndex] > MarketSeries.Open[PrevBarIndex])
					Result = 0;
        	if(MarketSeries.Close[LastBarIndex] < MarketSeries.Open[LastBarIndex])
				if(MarketSeries.Close[PrevBarIndex] < MarketSeries.Open[PrevBarIndex])
					Result = 1;
        	return Result;
        }
    }
}