Categoria: AlgoTrading

using System;
using System.Linq;
using cAlgo.API;
using cAlgo.API.Indicators;
using cAlgo.API.Internals;
using cAlgo.Indicators;

namespace cAlgo.Robots
{
    [Robot(TimeZone = TimeZones.UTC, AccessRights = AccessRights.None)]
    public class IIScalping : Robot
    {

        [Parameter("Source", Group = "Data series")]
        public DataSeries Source { get; set; }

        [Parameter(DefaultValue = 10)]
        public double takeProfit { get; set; }

        [Parameter(DefaultValue = 10)]
        public double stopLoss { get; set; }

        [Parameter(DefaultValue = 8)]
        public int hourEnter { get; set; }

        [Parameter(DefaultValue = 18)]
        public int hourExit { get; set; }

        [Parameter(DefaultValue = 60)]
        public int fastPeriod { get; set; }

        [Parameter(DefaultValue = 240)]
        public int slowPeriod { get; set; }

        [Parameter(DefaultValue = 0.01)]
        public double lots { get; set; }

        [Parameter(DefaultValue = 2)]
        public int multiplier { get; set; }

        [Parameter(DefaultValue = 1)]
        public int maxOrder { get; set; }

        [Parameter(DefaultValue = 8)]
        public int stochLength { get; set; }

        [Parameter(DefaultValue = 3)]
        public int stochParams { get; set; }

        private ExponentialMovingAverage emaFast;
        private ExponentialMovingAverage emaSlow;
        private StochasticOscillator stoch;
        
        double stochLevel = 0.0;


        protected override void OnStart()
        {
            // Put your initialization logic here

        }

        protected override void OnBar()
        {
            // Put your core logic here
            emaFast = Indicators.ExponentialMovingAverage(Source, fastPeriod);
            emaSlow = Indicators.ExponentialMovingAverage(Source, slowPeriod);
            stoch = Indicators.StochasticOscillator(stochLength, stochParams, stochParams, MovingAverageType.Exponential);
            
            
            int currentBar = Bars.Count - 1;
            bool check = checkTime();
            var positions = Positions.FindAll("Order");
            if (check == true)
            {
                

                //Open(TradeType.Buy, lots);
                
                if(emaFast.Result.LastValue > emaSlow.Result.LastValue && stoch.PercentK[currentBar] > stoch.PercentD[currentBar] && stoch.PercentK[currentBar - 1] <= 20 && stochLevel == 0.0){
                    stochLevel = Bars.LastBar.Close;
                }
                
                if(emaFast.Result.LastValue < emaSlow.Result.LastValue && stoch.PercentK[currentBar] < stoch.PercentD[currentBar] && stoch.PercentK[currentBar - 1] >= 80 && stochLevel == 0.0){
                    stochLevel = Bars.LastBar.Close;
                }

                if (emaFast.Result.LastValue > emaSlow.Result.LastValue && stoch.PercentK[currentBar] > stoch.PercentD[currentBar] && stoch.PercentK[currentBar - 1] <= 20 && Bars.LastBar.Close > stochLevel)
                {
                    stochLevel = 0.0;
                    //stopLoss = (Bars[currentBar-1].Close - Bars[currentBar-1].Low)*100000;
                    Open(TradeType.Buy, lots);
                }

                if (emaFast.Result.LastValue < emaSlow.Result.LastValue && stoch.PercentK[currentBar] < stoch.PercentD[currentBar] && stoch.PercentK[currentBar - 1] >= 80 && Bars.LastBar.Close < stochLevel)
                {
                    stochLevel = 0.0;
                    //stopLoss = (Bars[currentBar-1].High - Bars[currentBar-1].Close)*100000;
                    Open(TradeType.Sell, lots);
                }

            }
            
            if(positions.Length>0 && (positions[0].TradeType == TradeType.Buy)){
                if(stoch.PercentK[currentBar] >= 80){
                    Close(TradeType.Buy);
                }
            }
            
            
            if(positions.Length>0 && (positions[0].TradeType == TradeType.Buy)){
                if(stoch.PercentK[currentBar] <= 20){
                    Close(TradeType.Sell);
                }
            }

        }

        protected override void OnStop()
        {
            // Put your deinitialization logic here
        }

        private bool checkTime()
        {
            DateTime date = Server.Time;
            if (date.Hour >= hourEnter && date.Hour <= hourExit)
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        private void Close(TradeType tradeType)
        {
            foreach (var position in Positions.FindAll("Order", SymbolName, tradeType))
                ClosePosition(position);
        }

        private void Open(TradeType tradeType, double lots)
        {
            var position = Positions.FindAll("Order", SymbolName, tradeType);
            var volumeInUnits = Symbol.QuantityToVolumeInUnits(lots);
            if (position == null || position.Length < maxOrder)
                ExecuteMarketOrder(tradeType, SymbolName, volumeInUnits, "Order", stopLoss, takeProfit);
        }
    }


}