Params
    Numeric RiskRatio(1);                   // % Risk Per N ( 0 - 100)
    Numeric ATRLength(20);                  // 平均波动周期 ATR Length
    Numeric boLength(20);                   // 短周期 BreakOut Length
    Numeric fsLength(55);                   // 长周期 FailSafe Length
    Numeric teLength(10);                   // 离市周期 Trailing Exit Length
    Bool LastProfitableTradeFilter(True);   // 使用入市过滤条件
Vars
    Numeric N;                              // N 值
    Numeric TotalEquity;                    // 按最新收盘价计算出的总资产
    Numeric TurtleUnits;                    // 交易单位
    NumericSeries DonchianHi;              // 唐奇安通道上轨，延后1个Bar
    NumericSeries DonchianLo;              // 唐奇安通道下轨，延后1个Bar
    NumericSeries fsDonchianHi;            // 唐奇安通道上轨，延后1个Bar，长周期
    NumericSeries fsDonchianLo;            // 唐奇安通道下轨，延后1个Bar，长周期
    Numeric ExitHighestPrice;               // 离市时判断需要的N周期最高价
    Numeric ExitLowestPrice;                // 离市时判断需要的N周期最低价
    Numeric myEntryPrice;                   // 开仓价格
    Numeric myExitPrice;                    // 平仓价格
    Bool IsEntryThisBar(False);            // 当前Bar开过仓
    Bool IsAddThisBar(False);              // 当前Bar有过增仓
    Bool LastBreakoutWin(False);           // 最后一次突破是否盈利
    Numeric preEntryPrice;                 // 前一次开仓的价格，存放到全局变量0号位置
    Numeric preBreakoutType(0);            // 前一次突破的方向，1 - LONG , -1 - SHORT 初始值为0，存放到全局变量1号位置
    Numeric preBreakOutPrice;              // 前一次突破的价格，存放到全局变量2号位置
Begin
    If(BarStatus == 0)
    {
        SetGlobalVar(0,InvalidNumeric);
        SetGlobalVar(1,0);
        SetGlobalVar(2,InvalidNumeric);
    }Else
    {
        preBreakoutType = GetGlobalVar(1);
        preBreakOutPrice = GetGlobalVar(2);
    }

    N = AverageFC(TrueRange,ATRLength);
    TotalEquity = CurrentCapital()+ Abs(CurrentContracts()*Close*ContractUnit()*BigPointValue()*MarginRatio());
    TurtleUnits = (TotalEquity*RiskRatio/100) /(N * ContractUnit()*BigPointValue());
    TurtleUnits = IntPart(TurtleUnits); // 对小数取整

    DonchianHi = HighestFC(Close[1],boLength);
    DonchianLo = LowestFC(Close[1],boLength);

    // 判断最后一次突破是否盈利
    If(preBreakoutType == 1)
    {
        If(Close > PreBreakOutPrice)
        {
            LastBreakoutWin = True;
        }
    }Else If(preBreakoutType == -1)
    {
        If(Close < PreBreakOutPrice)
        {
            LastBreakoutWin = True;
        }
    }

    // 当不使用过滤条件，或者使用过滤条件并且条件为False进行后续操作
    If((Not LastProfitableTradeFilter) Or (NOT LastBreakoutWin))
    {
        // 突破开仓
        If(CrossOver(High,DonchianHi) && TurtleUnits >= 1)
        {
            // 开仓价格取突破上轨+一个价位和最高价之间的较小值，这样能更接近真实情况，并能尽量保证成交
            preBreakoutType = 1;
            preBreakOutPrice = Donchianhi;
            SetGlobalVar(1,preBreakoutType);
            SetGlobalVar(2,preBreakOutPrice);

            myEntryPrice = min(high,DonchianHi + PriceScale*MinMove);
            myEntryPrice = IIF(myEntryPrice < Open, Open,myEntryPrice); // 大跳空的时候用开盘价代替
            If(Buy(TurtleUnits,myEntryPrice))
            {
                IsEntryThisBar = True;
                SetGlobalVar(0,myEntryPrice);// 保存第一次开仓的价格
            }
        }

        If(CrossUnder(Low,DonchianLo) && TurtleUnits >= 1)
        {

            // 开仓价格取突破下轨-一个价位和最低价之间的较大值，这样能更接近真实情况，并能尽量保证成交
            preBreakoutType = -1;
            preBreakOutPrice = DonchianLo;
            SetGlobalVar(1,preBreakoutType);
            SetGlobalVar(2,preBreakOutPrice);

            myEntryPrice = max(low,DonchianLo - PriceScale*MinMove);
            myEntryPrice = IIF(myEntryPrice > Open, Open,myEntryPrice); // 大跳空的时候用开盘价代替
            If(SellShort(TurtleUnits,myEntryPrice))
            {
                IsEntryThisBar = True;
                SetGlobalVar(0,myEntryPrice);// 保存第一次开仓的价格
            }
        }
    }

    // 长周期突破开仓 Failsafe Breakout point
    If(MarketPosition == 0)
    {
        fsDonchianHi = HighestFC(Close[1],fsLength);
        fsDonchianLo = LowestFC(Close[1],fsLength);

        If(CrossOver(High,fsDonchianHi) && TurtleUnits >= 1)
        {
            // 开仓价格取突破上轨+一个价位和最高价之间的较小值，这样能更接近真实情况，并能尽量保证成交
            myEntryPrice = min(high,fsDonchianHi + PriceScale*MinMove);
            myEntryPrice = IIF(myEntryPrice < Open, Open,myEntryPrice); // 大跳空的时候用开盘价代替
            If(Buy(TurtleUnits,myEntryPrice))
            {
                IsEntryThisBar = True;
            }
        }

        If(CrossUnder(Low,fsDonchianLo) && TurtleUnits >= 1)
        {
            // 开仓价格取突破下轨-一个价位和最低价之间的较大值，这样能更接近真实情况，并能尽量保证成交
            myEntryPrice = max(low,fsDonchianLo - PriceScale*MinMove);
            myEntryPrice = IIF(myEntryPrice > Open, Open,myEntryPrice); // 大跳空的时候用开盘价代替
            If(SellShort(TurtleUnits,myEntryPrice))
            {
                IsEntryThisBar = True;
            }
        }
    }

    If(MarketPosition == 1) // 有多仓的情况
    {
        // 求出持多仓时离市的条件比较值
        ExitLowestPrice = LowestFC(Low[1],teLength);
        If(Low < ExitLowestPrice)
        {
            myExitPrice = max(Low,ExitLowestPrice - PriceScale()*MinMove());
            Sell(0,myExitPrice);    // 数量用0的情况下将全部平仓
        }Else If(IsEntryThisBar)
        {
            // 当前Bar开过仓的情况，如果Close比myEntryPrice大于1/2N.用收盘价加仓。
            If(Close >= myEntryPrice + 0.5 * N && TurtleUnits >= 1)
            {
                myEntryPrice = myEntryPrice + 0.5 * N;
                If(Buy(TurtleUnits,myEntryPrice))
                {
                    SetGlobalVar(0,myEntryPrice);// 保存最后一次开仓的价格
                }
            }

            // 加上止损指令
            If(Close <= MyEntryPrice - 2 * N)
            {
                myExitPrice = MyEntryPrice - 2 * N;
                Sell(0,myExitPrice); // 数量用0的情况下将全部平仓
            }
        }Else
        {
            preEntryPrice = GetGlobalVar(0); // 取出上一次开仓的价格
            If(preEntryPrice!=InvalidNumeric && TurtleUnits >= 1)
            {
                If(Open >= preEntryPrice + 0.5*N) // 如果开盘就超过设定的1/2N,则直接用开盘价增仓。
                {
                    myEntryPrice = Open;
                    If(Buy(TurtleUnits,myEntryPrice))
                    {
                        preEntryPrice = myEntryPrice;
                        IsAddThisBar = True;
                        SetGlobalVar(0,preEntryPrice);// 保存最后一次开仓的价格
                    }
                }

                while(High >= preEntryPrice + 0.5*N) // 以最高价为标准，判断能进行几次增仓
                {
                    myEntryPrice = preEntryPrice + 0.5 * N;
                    preEntryPrice = myEntryPrice;
                    If(Buy(TurtleUnits,myEntryPrice))
                    {
                        IsAddThisBar = True;
                        SetGlobalVar(0,preEntryPrice);// 保存最后一次开仓的价格
                    }
                }
            }

            // 止损指令
            If(IsAddThisBar)
            {
                // 当前Bar有过增仓，此时不能直接按Low来判断是否止损，因为不能确定Bar的价格的走势，只按收盘价进行止损判断。
                If(Close <= preEntryPrice - 2 * N)
                {
                    myExitPrice = preEntryPrice - 2 * N;
                    Sell(0,myExitPrice); // 数量用0的情况下将全部平仓
                }
            }Else
            {
                If(Low <= preEntryPrice - 2 * N)
                {
                    myExitPrice = preEntryPrice - 2 * N;
                    Sell(0,myExitPrice); // 数量用0的情况下将全部平仓
                }
            }
        }
    }Else If(MarketPosition ==-1) // 有空仓的情况
    {
        // 求出持空仓时离市的条件比较值
        ExitHighestPrice = HighestFC(High[1],teLength);
        If(High > ExitHighestPrice )
        {
            myExitPrice = Min(High,ExitHighestPrice + PriceScale()*MinMove());
            BuyToCover(0,ExitHighestPrice);    // 数量用0的情况下将全部平仓
        }Else If(IsEntryThisBar)
        {
            // 当前Bar开过仓的情况，如果Close比myEntryPrice小于1/2N.用收盘价加仓。
            If(Close <= myEntryPrice - 0.5 * N && TurtleUnits >= 1)
            {
                myEntryPrice = myEntryPrice - 0.5 * N;
                If(SellShort(TurtleUnits,myEntryPrice))
                {
                    SetGlobalVar(0,myEntryPrice);// 保存最后一次开仓的价格
                }
            }

            // 加上止损指令
            If(Close >= MyEntryPrice + 2 * N)
            {
                myExitPrice = MyEntryPrice + 2 * N;
                BuyToCover(0,myExitPrice); // 数量用0的情况下将全部平仓
            }
        }Else
        {
            preEntryPrice = GetGlobalVar(0); // 取出上一次开仓的价格
            If(preEntryPrice!=InvalidNumeric && TurtleUnits >= 1)
            {
                If(Open <= preEntryPrice - 0.5*N) // 如果开盘就超过设定的1/2N,则直接用开盘价增仓。
                {
                    myEntryPrice = Open;
                    If(SellShort(TurtleUnits,myEntryPrice))
                    {
                        preEntryPrice = myEntryPrice;
                        IsAddThisBar = True;
                        SetGlobalVar(0,preEntryPrice);// 保存最后一次开仓的价格
                    }
                }

                while(Low <= preEntryPrice - 0.5*N) // 以最低价为标准，判断能进行几次增仓
                {
                    myEntryPrice = preEntryPrice - 0.5 * N;
                    preEntryPrice = myEntryPrice;
                    If(SellShort(TurtleUnits,myEntryPrice))
                    {
                        IsAddThisBar = True;
                        SetGlobalVar(0,preEntryPrice);// 保存最后一次开仓的价格
                    }
                }
            }

            // 止损指令
            If(IsAddThisBar)
            {
                // 当前Bar有过增仓，此时不能直接按High来判断是否止损，因为不能确定Bar的价格的走势，只按收盘价进行止损判断。
                If(Close >= preEntryPrice + 2 * N)
                {
                    myExitPrice = preEntryPrice + 2 * N;
                    BuyToCover(0,myExitPrice); // 数量用0的情况下将全部平仓
                }
            }Else
            {
                If(High >= preEntryPrice + 2 * N)
                {
                    myExitPrice = preEntryPrice + 2 * N;
                    BuyToCover(0,myExitPrice); // 数量用0的情况下将全部平仓
                }
            }
        }
    }
End