松脚本代码，停到收支平衡。但我想不出

Question

我正在编写这个YouTube策略。我做了大部分，但我不知道如何编写“停止到盈亏平衡”的代码，所以这个策略只有一个入口和一个出口。有人能帮我吗？我希望在第一个TP (1 X atr)时采取50%的位置，并在ssl通道穿过This is the strategy video上的相反方向时将盈亏平衡止损放在入口和出口的剩余位置

//@version=4
strategy("for jcolina1 v2",overlay=true)
//Inputs------------------------------------------------------------------------
startDate        = input(timestamp("2020-07-30T00:00:00"), type = input.time, group="Back-testing range")
finishDate       = input(timestamp("2022-09-09T00:00:00"), type = input.time, group="Back-testing range")
profit_multiplier= input(1,title="profit multiplier", type=input.float)
stop_multiplier  = input(1.5, title="stop loss multiplier", type=input.float)
level_offset     = input(5, type=input.integer, title="Length", group="levels") 
bearish_levels   = input(color.new(color.red,0), type=input.color,title="Bearish", inline ="0",group="levels" )
bearish_L_text   = input(color.new(color.purple,0), type=input.color,title="text", inline="0", group="levels")
Bullish_levels   = input(color.new(color.green,0), type=input.color,title="Bullish", inline ="00",group="levels" )
Bullish_L_text   = input(color.new(color.yellow,0), type=input.color,title="text", inline="00", group="levels")
ssl_len          = input(title="ssl length", defval=10,inline="1",group="Base indicators")
en_ssl           = input(true,title=" ", type=input.bool,inline="1",group="Base indicators")
Up               = input(#66ff00, type=input.color,title="Up", inline="1",group="Base indicators")
Dn               = input(#ff0000, type=input.color, title="Dn", inline="1",group="Base indicators")
kiju_len         = input(26, minval=1, title="Kijun-Sen",type=input.integer,inline="2",group="Base indicators")
en_ki            = input(true,title=" ", type=input.bool,inline="2",group="Base indicators")
col_kijun        = input(color.white, type=input.color, title=" ", inline="2", group="Base indicators")
Sensitivity      = input(150, title="Sensitivity", type=input.integer,group="Waddah attar explosion")
Fast_Length      = input(20 , title="Fast Length", type=input.integer,group="Waddah attar explosion")
Slow_Length      = input(40 , title="Slow Length", type=input.integer,group="Waddah attar explosion")
Channel_Length   = input(20 , title="Channel Length",type=input.integer,group="Waddah attar explosion")
Multi            = input(2.0, title="BB Multi",type=input.float,group="Waddah attar explosion")
//Computing required calculations-----------------------------------------------
smaHigh = sma(high, ssl_len)
smaLow = sma(low, ssl_len)
Hlv = int(na)
Hlv := close > smaHigh ? 1 : close < smaLow ? -1 : Hlv[1]
sslDown = Hlv < 0 ? smaHigh : smaLow //output
sslUp = Hlv < 0 ? smaLow : smaHigh  // output
donchian(d_len) =>
    avg(lowest(d_len), highest(d_len))
baseLine = donchian(kiju_len)
Calc_Macd(Source, Fast_Length, Slow_Length) =>
    Fast_Ma         =   ema(Source, Fast_Length)
    Slow_Ma         =   ema(Source, Slow_Length)
    Fast_Ma - Slow_Ma
Calc_Upper(Source, length, Multi) =>
    Basis           =   sma(Source, length)
    Dev             =   Multi * stdev(Source, length)
    Basis + Dev
Calc_Lower(Source, length, Multi) =>
    Basis           =   sma(Source, length)
    Dev = Multi * stdev(Source, length)
    Basis - Dev
t1  = (Calc_Macd(close, Fast_Length, Slow_Length) - Calc_Macd(close[1], Fast_Length, Slow_Length)) * Sensitivity
e1  = Calc_Upper(close, Channel_Length, Multi) - Calc_Lower(close, Channel_Length, Multi)
trendUp   =   t1 >= 0 ? t1 : 0
trendDown =   t1 < 0 ? -1 * t1 : 0
DEAD_ZONE =   nz(rma(tr(true),100)) * 3.7
atr = atr(14)
time_cond  = time >= startDate and time <= finishDate
// entry logic------------------------------------------------------------------
ssl_bul = crossover(sslUp,sslDown) , ssl_bear = crossunder(sslUp,sslDown)
kij_bul = (close > baseLine) , kij_bear = (close < baseLine)
wae_filter = ((trendUp > e1) or (trendDown > e1))
bullish = ((ssl_bul and kij_bul) and wae_filter)
bearish = ((ssl_bear and kij_bear) and wae_filter)
// computing required dynamic data for short
var float S_stop   = na 
var float S_entry  = na
var float S_target = na 
if ((bearish and barstate.isconfirmed) and time_cond)
    S_entry := close
    S_stop := (close + (atr * stop_multiplier))
    S_target := (close - (atr * profit_multiplier ))
    strategy.entry("Short", strategy.short)
    strategy.exit("S exit", "Short",limit = S_target, stop = S_stop)
    
    tt = (time - time[1]) * level_offset
    //stop
    line.new(x1=time, y1=S_stop,
         x2=time + tt , y2=S_stop , color=bearish_levels,
         xloc=xloc.bar_time,width=2)
    label.new(x=time +(time - time[1]), y=S_stop, text=tostring(S_stop)+" short SL",color=color.new(color.black,100), style=label.style_label_lower_left,textcolor=bearish_L_text,xloc=xloc.bar_time,textalign= text.align_left)
    //target
    line.new(x1=time, y1=S_target,
         x2=time + tt , y2=S_target , color=bearish_levels,
         xloc=xloc.bar_time,width=2)
    label.new(x=time +(time - time[1]) , y=S_target, text=tostring(S_target)+" short TP",color=color.new(color.black,100), style=label.style_label_upper_left,textcolor=bearish_L_text,xloc=xloc.bar_time,textalign= text.align_left)

// computing required dynamic data for long
var float L_stop   = na 
var float L_entry  = na
var float L_target = na 
if ((bullish and barstate.isconfirmed) and time_cond)
    L_entry := close
    L_stop := (close - (atr * stop_multiplier))
    L_target := (close + (atr * profit_multiplier ))
    strategy.entry("Long", strategy.long)
    strategy.exit("L exit", "Long",limit = L_target, stop = L_stop)
    tt = (time - time[1]) * level_offset
    //stop
    line.new(x1=time, y1=L_stop,
         x2=time + tt , y2=L_stop , color=Bullish_levels,
         xloc=xloc.bar_time,width=2)
    label.new(x=time +(time - time[1]), y=L_stop, text=tostring(L_stop)+" Long SL",color=color.new(color.black,100), style=label.style_label_upper_left,textcolor=Bullish_L_text,xloc=xloc.bar_time,textalign= text.align_left)
    //target
    line.new(x1=time, y1=L_target,
         x2=time + tt , y2=L_target , color=Bullish_levels,
         xloc=xloc.bar_time,width=2)
    label.new(x=time +(time - time[1]) , y=L_target, text=tostring(L_target)+" Lomg TP",color=color.new(color.black,100), style=label.style_label_lower_left,textcolor=Bullish_L_text,xloc=xloc.bar_time,textalign= text.align_left)

// signals -------------------------------------------------

if (bullish and time_cond)
    lbl = label.new(bar_index, low,text = "Buy" ,textcolor = color.white)
    label.set_color(lbl,color.green)
    label.set_yloc(lbl,yloc.belowbar)
    label.set_style(lbl,label.style_label_up)
if (bearish and time_cond)
    lbl = label.new(bar_index, low,text ="Sell",textcolor = color.white)
    label.set_color(lbl,color.red)
    label.set_yloc(lbl,yloc.abovebar)
    label.set_style(lbl,label.style_label_down)
    
//Ploting the data------------------------------------------------------------------------
plot(en_ssl ? sslDown : na, linewidth=2, color=Up)
plot(en_ssl ? sslUp   : na, linewidth=2, color=Dn)
plot(en_ki ? baseLine : na, color=col_kijun, title="Kijun-Sen")

Answer 1

根据您对策略的描述，您必须为每个入场设置两个退出顺序。第一个应该描述如何退出前50%，第二个应该描述另一半。不同的是，另一半应该只有止损，而前一半应该既有获利又有止损。尝试将第68-69行替换为

strategy.entry("Short", strategy.short)
strategy.exit("S exit1", "Short", from_entry = "Short", qty_percent = 50, limit = S_target, stop = S_stop)
strategy.exit("S exit2", "Short", from_entry = "Short", stop = S_stop)

而第91-92行包含

strategy.entry("Long", strategy.long)
strategy.exit("L exit1", "Long", from_entry = "Long", qty_percent = 50, limit = L_target, stop = L_stop)
strategy.exit("L exit2", "Long", from_entry = "Long", stop = L_stop)

请注意，qty_percent = 50将使退出指令"S exit1“仅退出初始”空头“指令的一半！

此外，出于调试目的，最好在您的策略上设置金字塔= 0，这样您就只有一个活动的订单需要处理。

要将exit2订单的止损设置为盈亏平衡，您需要知道是否激活了获利了结指令。您可以通过监视strategy.position_size来实现此目的

例如，类似于

var longTakeProfitExecuted = false
...

longTakeProfitExecuted := strategy.position_size > 0 and (longTakeProfitExecuted[1] or strategy.position_size < strategy.position_size[1] or (strategy.position_size[1] == 0 and high >= L_target))

然后，您可以使用此信息来设置正确的止损价格。

strategy.exit("L exit2", "Long", from_entry = "Long", stop = longTakeProfitExecuted ? Breakeven_stop : L_stop)