Option Strategy P&L Tracker: Multi-Leg with SL & Re-entry

thescalpeltrader · study · 550 行 · 点赞 34 · TradingView 原页

本页源码来自 TradingView 公开发布的开源脚本,版权归原作者所有, 请遵循其原始许可(Pine 脚本常见 CC BY-NC-SA / MPL-2.0 / MIT)。 本项目仅用于研究检索与许可范围内的移植。

Pine Script

//@version=6
// This Pine Script® code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © thescalpeltrader
indicator("Option Strategy P&L Tracker: Multi-Leg with SL & Re-entry", shorttitle = "Strategy P&L", overlay = false, max_lines_count = 50, max_labels_count = 50)
 
// ═════════════ INPUTS · POSITION ═════════════
const string GPOS = "Position"
entryTime = input.time(timestamp("06 Nov 2026 09:20 +0530"), "Entry time (click a bar)", confirm = true, group = GPOS, display = display.none)
lotSize   = input.int(65, "Lot size (units per lot)", minval = 1, group = GPOS, display = display.none, tooltip = "Verify the current exchange lot size of your underlying.")
sqOn      = input.bool(true, "Intraday square-off at", group = GPOS, inline = "sq", display = display.none)
sqH       = input.int(15, "", minval = 0, maxval = 23, group = GPOS, inline = "sq", display = display.none)
sqM       = input.int(15, ":", minval = 0, maxval = 59, group = GPOS, inline = "sq", display = display.none)
slipPct   = input.float(0.5, "Slippage per fill (%)", minval = 0, step = 0.1, group = GPOS, display = display.none)
 
// ═════════════ INPUTS · LEGS ═════════════
const string G1 = "Leg 1"
s1  = input.symbol("", "Contract", group = G1, confirm = true, display = display.none)
sd1 = input.string("Sell", "Side", options = ["Sell", "Buy"], group = G1, inline = "1a", display = display.none)
l1  = input.int(1, "Lots", minval = 1, group = G1, inline = "1a", display = display.none)
e1  = input.float(0.0, "Entry (0 = auto)", minval = 0, group = G1, inline = "1a", display = display.none)
st1 = input.string("% of premium", "SL", options = ["% of premium", "Points", "None"], group = G1, inline = "1b", display = display.none)
sv1 = input.float(30.0, "", minval = 0, group = G1, inline = "1b", display = display.none)
rm1 = input.string("Off", "Re-entry", options = ["Off", "RE-ASAP", "RE-ASAP ↩", "RE-COST", "RE-COST ↩"], group = G1, inline = "1c", display = display.none)
rn1 = input.int(1, "max", minval = 0, maxval = 10, group = G1, inline = "1c", display = display.none)
 
const string G2 = "Leg 2"
s2  = input.symbol("", "Contract", group = G2, display = display.none)
sd2 = input.string("Sell", "Side", options = ["Sell", "Buy"], group = G2, inline = "2a", display = display.none)
l2  = input.int(1, "Lots", minval = 1, group = G2, inline = "2a", display = display.none)
e2  = input.float(0.0, "Entry (0 = auto)", minval = 0, group = G2, inline = "2a", display = display.none)
st2 = input.string("% of premium", "SL", options = ["% of premium", "Points", "None"], group = G2, inline = "2b", display = display.none)
sv2 = input.float(30.0, "", minval = 0, group = G2, inline = "2b", display = display.none)
rm2 = input.string("Off", "Re-entry", options = ["Off", "RE-ASAP", "RE-ASAP ↩", "RE-COST", "RE-COST ↩"], group = G2, inline = "2c", display = display.none)
rn2 = input.int(1, "max", minval = 0, maxval = 10, group = G2, inline = "2c", display = display.none)
 
const string G3 = "Leg 3"
s3  = input.symbol("", "Contract", group = G3, display = display.none)
sd3 = input.string("Buy", "Side", options = ["Sell", "Buy"], group = G3, inline = "3a", display = display.none)
l3  = input.int(1, "Lots", minval = 1, group = G3, inline = "3a", display = display.none)
e3  = input.float(0.0, "Entry (0 = auto)", minval = 0, group = G3, inline = "3a", display = display.none)
st3 = input.string("None", "SL", options = ["% of premium", "Points", "None"], group = G3, inline = "3b", display = display.none)
sv3 = input.float(30.0, "", minval = 0, group = G3, inline = "3b", display = display.none)
rm3 = input.string("Off", "Re-entry", options = ["Off", "RE-ASAP", "RE-ASAP ↩", "RE-COST", "RE-COST ↩"], group = G3, inline = "3c", display = display.none)
rn3 = input.int(1, "max", minval = 0, maxval = 10, group = G3, inline = "3c", display = display.none)
 
const string G4 = "Leg 4"
s4  = input.symbol("", "Contract", group = G4, display = display.none)
sd4 = input.string("Buy", "Side", options = ["Sell", "Buy"], group = G4, inline = "4a", display = display.none)
l4  = input.int(1, "Lots", minval = 1, group = G4, inline = "4a", display = display.none)
e4  = input.float(0.0, "Entry (0 = auto)", minval = 0, group = G4, inline = "4a", display = display.none)
st4 = input.string("None", "SL", options = ["% of premium", "Points", "None"], group = G4, inline = "4b", display = display.none)
sv4 = input.float(30.0, "", minval = 0, group = G4, inline = "4b", display = display.none)
rm4 = input.string("Off", "Re-entry", options = ["Off", "RE-ASAP", "RE-ASAP ↩", "RE-COST", "RE-COST ↩"], group = G4, inline = "4c", display = display.none)
rn4 = input.int(1, "max", minval = 0, maxval = 10, group = G4, inline = "4c", display = display.none)
 
// ═════════════ INPUTS · RULES, CHARGES, DISPLAY ═════════════
const string GT = "Trailing SL (all legs with an SL)"
trOn = input.bool(false, "Trail SL · for every", group = GT, inline = "t", display = display.none)
trX  = input.float(10.0, "", minval = 0.01, group = GT, inline = "t", display = display.none)
trY  = input.float(5.0, "move SL by", minval = 0, group = GT, inline = "t", display = display.none, tooltip = "Same unit as each leg's SL: % of entry premium, or points.")
 
const string GP = "Position MTM rules (₹, net of charges)"
pSL  = input.float(0.0, "Position SL (0 = off)", minval = 0, group = GP, display = display.none)
pTG  = input.float(0.0, "Position target (0 = off)", minval = 0, group = GP, display = display.none)
lkOn = input.bool(false, "Lock profit · when MTM reaches", group = GP, inline = "lk", display = display.none)
lkAt = input.float(3000.0, "", minval = 0, group = GP, inline = "lk", display = display.none)
lkTo = input.float(1000.0, "lock", minval = 0, group = GP, inline = "lk", display = display.none)
lkSt = input.float(1000.0, "Then every +", minval = 0, group = GP, inline = "lk2", display = display.none)
lkBy = input.float(500.0, "raise lock by", minval = 0, group = GP, inline = "lk2", display = display.none)
 
const string GC = "Charges per fill (edit to match your broker & exchange)"
cBrk  = input.float(20.0, "Brokerage per order (₹)", minval = 0, group = GC, display = display.none)
cStt  = input.float(0.15, "STT on sell premium (%)", minval = 0, step = 0.005, group = GC, display = display.none)
cTxn  = input.float(0.03553, "Exchange txn (% of premium)", minval = 0, step = 0.0001, group = GC, display = display.none)
cSebi = input.float(0.0001, "SEBI fee (%)", minval = 0, step = 0.0001, group = GC, display = display.none)
cStmp = input.float(0.003, "Stamp duty on buys (%)", minval = 0, step = 0.001, group = GC, display = display.none)
cGst  = input.float(18.0, "GST (%) on brokerage + txn + SEBI", minval = 0, group = GC, display = display.none)
 
const string GG = "Greeks & payoff"
rRate     = input.float(6.5, "Risk-free rate (%)", group = GG, display = display.none)
showGreek = input.bool(true, "Net Greeks in table", group = GG, display = display.none)
showPay   = input.bool(true, "Breakevens & short strikes on price chart", group = GG, display = display.none)
payRange  = input.float(10.0, "Payoff range (± % of spot)", minval = 1, maxval = 50, group = GG, display = display.none)
 
const string GD = "Display"
tblPos = input.string("Top right", "Table position", options = ["Top right", "Bottom right", "Top left", "Bottom left"], group = GD, display = display.none)
logN   = input.int(6, "Event log rows", minval = 0, maxval = 12, group = GD, display = display.none)
 
// ═════════════ TYPES & STATE ═════════════
type Bars
    array<int>   t
    array<float> o
    array<float> h
    array<float> l
    array<float> c
 
type Leg
    string sym
    bool   on
    string name
    string optType
    float  strike
    int    expiry
    int    side
    float  qty
    float  ovr
    string slType
    float  slVal
    string reMode
    int    reMax
    int    state    = 0      // 0 waiting · 1 open · 2 stopped, awaiting re-entry · 3 done
    float  entry
    float  ref
    float  sl
    float  sl0
    float  best
    float  trStep
    float  trMove
    int    reCount  = 0
    float  realized = 0.0
    float  charges  = 0.0
    float  last
 
var array<Leg>    legs      = array.new<Leg>()
var array<string> evLog     = array.new<string>()
var bool          posDone   = false
var string        exitWhy   = ""
var float         lockFloor = na
var float         prevMtm   = na
 
sqTime = timestamp("Asia/Kolkata", year(entryTime, "Asia/Kolkata"), month(entryTime, "Asia/Kolkata"), dayofmonth(entryTime, "Asia/Kolkata"), sqH, sqM)
 
// ═════════════ HELPERS ═════════════
f_parse(string sym) =>
    string tk  = str.contains(sym, ":") ? str.split(sym, ":").get(1) : sym
    string m   = str.match(tk, "[0-9]{6}[CP][0-9]+(\\.[0-9]+)?$")
    string typ = ""
    float  k   = na
    int    exp = na
    if m != ""
        int yy = int(str.tonumber(str.substring(m, 0, 2)))
        int mm = int(str.tonumber(str.substring(m, 2, 4)))
        int dd = int(str.tonumber(str.substring(m, 4, 6)))
        typ := str.substring(m, 6, 7)
        k   := str.tonumber(str.substring(m, 7))
        exp := timestamp("Asia/Kolkata", 2000 + yy, mm, dd, 15, 30)
    [tk, typ, k, exp]
 
f_mk(string s, string sd, int lots, float ovr, string slT, float slV, string rm, int rn) =>
    [tk, typ, k, exp] = f_parse(s)
    Leg lg = Leg.new()
    lg.sym     := s
    lg.on      := s != ""
    lg.optType := typ
    lg.strike  := k
    lg.expiry  := exp
    lg.name    := na(k) ? tk : str.tostring(k, "#.##") + (typ == "C" ? " CE" : " PE")
    lg.side    := sd == "Buy" ? 1 : -1
    lg.qty     := lots * lotSize
    lg.ovr     := ovr
    lg.slType  := slT
    lg.slVal   := slV
    lg.reMode  := rm
    lg.reMax   := rn
    lg
 
f_req(simple string s) =>
    request.security_lower_tf(s == "" ? syminfo.tickerid : s, "1", [time, open, high, low, close], ignore_invalid_symbol = true)
 
f_chg(float px, float q, bool isSell) =>
    float tv   = px * q
    float stt  = isSell ? tv * cStt / 100 : 0.0
    float txn  = tv * cTxn / 100
    float sebi = tv * cSebi / 100
    float stmp = isSell ? 0.0 : tv * cStmp / 100
    float gst  = (cBrk + txn + sebi) * cGst / 100
    cBrk + stt + txn + sebi + stmp + gst
 
f_log(int t, string msg) =>
    evLog.unshift(str.format_time(t, "dd MMM HH:mm", "Asia/Kolkata") + "  " + msg)
    if evLog.size() > 20
        evLog.pop()
    if barstate.isrealtime
        alert("Position P&L · " + msg, alert.freq_once_per_bar)
 
f_rs(float x) =>
    na(x) ? "—" : (x >= 0 ? "+₹" : "−₹") + str.tostring(math.abs(x), "#,##0")
 
// ═════════════ LEG ENGINE ═════════════
method openLeg(Leg lg, float px, int t, string tag) =>
    float fill = px * (1 + lg.side * slipPct / 100)
    lg.entry   := fill
    lg.charges += f_chg(fill, lg.qty, lg.side < 0)
    lg.state   := 1
    float unit = lg.slType == "% of premium" ? fill / 100 : 1.0
    lg.sl      := lg.slType == "None" ? na : fill - lg.side * lg.slVal * unit
    lg.sl0     := lg.sl
    lg.trStep  := trX * unit
    lg.trMove  := trY * unit
    lg.best    := fill
    f_log(t, lg.name + (lg.side > 0 ? " BUY @ " : " SELL @ ") + str.tostring(fill, "#.##") + tag)
 
method closeLeg(Leg lg, float px, int t, string why, int newState) =>
    float fill = px * (1 - lg.side * slipPct / 100)
    lg.realized += lg.side * (fill - lg.entry) * lg.qty
    lg.charges  += f_chg(fill, lg.qty, lg.side > 0)
    lg.state    := newState
    lg.last     := px
    f_log(t, lg.name + " " + why + " @ " + str.tostring(fill, "#.##"))
 
method step(Leg lg, int t, float o, float h, float l, float c) =>
    int ev = 0   // 1 entry · 2 SL · 3 re-entry
    if lg.on and not posDone
        if lg.state == 0
            if t >= entryTime
                float px = lg.ovr > 0 ? lg.ovr : o
                lg.ref := px
                lg.openLeg(px, t, "")
                ev := 1
        else if lg.state == 2
            bool rev = str.contains(lg.reMode, "↩")
            if str.startswith(lg.reMode, "RE-ASAP")
                if rev
                    lg.side := -lg.side
                lg.reCount += 1
                lg.ref := o
                lg.openLeg(o, t, "  (re-entry " + str.tostring(lg.reCount) + ")")
                ev := 3
            else if str.startswith(lg.reMode, "RE-COST")
                bool hit = lg.side < 0 ? l <= lg.ref : h >= lg.ref
                if hit
                    float px = lg.side < 0 ? math.min(o, lg.ref) : math.max(o, lg.ref)
                    if rev
                        lg.side := -lg.side
                    lg.reCount += 1
                    lg.ref := px
                    lg.openLeg(px, t, "  (re-entry " + str.tostring(lg.reCount) + ")")
                    ev := 3
        bool checkNow = lg.state == 1 and not (ev == 3 and str.startswith(lg.reMode, "RE-COST"))
        if checkNow
            bool slHit = not na(lg.sl) and (lg.side < 0 ? h >= lg.sl : l <= lg.sl)
            if slHit
                float px = lg.side < 0 ? math.max(o, lg.sl) : math.min(o, lg.sl)
                bool canRe = lg.reMode != "Off" and lg.reCount < lg.reMax
                lg.closeLeg(px, t, "SL hit", canRe ? 2 : 3)
                ev := 2
            else if trOn and not na(lg.sl) and lg.trStep > 0
                float fav = lg.side < 0 ? l : h
                lg.best := lg.side < 0 ? math.min(lg.best, fav) : math.max(lg.best, fav)
                float moved = (lg.best - lg.entry) * lg.side
                if moved > 0
                    int n = math.floor(moved / lg.trStep)
                    float nsl = lg.sl0 + lg.side * n * lg.trMove
                    lg.sl := lg.side < 0 ? math.min(lg.sl, nsl) : math.max(lg.sl, nsl)
        lg.last := c
    ev
 
f_mtm() =>
    float m = 0.0
    bool any = false
    for lg in legs
        if lg.on and lg.state > 0
            any := true
            m += lg.realized - lg.charges
            if lg.state == 1 and not na(lg.last)
                m += lg.side * (lg.last - lg.entry) * lg.qty
    any ? m : na
 
// ═════════════ DATA ═════════════
if barstate.isfirst
    legs.push(f_mk(s1, sd1, l1, e1, st1, sv1, rm1, rn1))
    legs.push(f_mk(s2, sd2, l2, e2, st2, sv2, rm2, rn2))
    legs.push(f_mk(s3, sd3, l3, e3, st3, sv3, rm3, rn3))
    legs.push(f_mk(s4, sd4, l4, e4, st4, sv4, rm4, rn4))
 
[t1, o1, h1, lo1, c1] = f_req(s1)
[t2, o2, h2, lo2, c2] = f_req(s2)
[t3, o3, h3, lo3, c3] = f_req(s3)
[t4, o4, h4, lo4, c4] = f_req(s4)
tu = request.security_lower_tf(syminfo.tickerid, "1", time)
array<Bars> bs = array.from(Bars.new(t1, o1, h1, lo1, c1), Bars.new(t2, o2, h2, lo2, c2), Bars.new(t3, o3, h3, lo3, c3), Bars.new(t4, o4, h4, lo4, c4))
 
// ═════════════ RUN (minute by minute inside each chart bar) ═════════════
float mtmO = na
float mtmH = na
float mtmL = na
float mtmC = na
bool evEN = false
bool evSL = false
bool evRE = false
bool evEX = false
 
int nU = na(tu) ? 0 : tu.size()
if nU > 0 and legs.size() == 4 and time_close >= entryTime
    array<int> ptr = array.new_int(4, 0)
    for i = 0 to nU - 1
        int tm = tu.get(i)
        for k = 0 to 3
            Leg  lg = legs.get(k)
            Bars b  = bs.get(k)
            int  nb = na(b.t) ? 0 : b.t.size()
            if lg.on and nb > 0
                int p = ptr.get(k)
                while p < nb and b.t.get(p) <= tm
                    int ev = lg.step(b.t.get(p), b.o.get(p), b.h.get(p), b.l.get(p), b.c.get(p))
                    evEN := evEN or ev == 1
                    evSL := evSL or ev == 2
                    evRE := evRE or ev == 3
                    p += 1
                ptr.set(k, p)
        float m = f_mtm()
        if not na(m)
            if not posDone
                string why = ""
                if pSL > 0 and m <= -pSL
                    why := "Position SL"
                else if pTG > 0 and m >= pTG
                    why := "Position target"
                if lkOn and m >= lkAt
                    float fl = lkTo + (lkSt > 0 ? math.floor((m - lkAt) / lkSt) * lkBy : 0.0)
                    lockFloor := na(lockFloor) ? fl : math.max(lockFloor, fl)
                if why == "" and lkOn and not na(lockFloor) and m <= lockFloor
                    why := "Profit lock"
                if why == "" and sqOn and tm >= sqTime
                    why := "Square-off"
                if why != ""
                    for lg in legs
                        if lg.on and lg.state == 1
                            lg.closeLeg(lg.last, tm, why, 3)
                        else if lg.on
                            lg.state := 3
                    posDone := true
                    exitWhy := why
                    evEX := true
                    m := f_mtm()
            mtmO := na(mtmO) ? (na(prevMtm) ? m : prevMtm) : mtmO
            mtmH := na(mtmH) ? math.max(m, mtmO) : math.max(mtmH, m)
            mtmL := na(mtmL) ? math.min(m, mtmO) : math.min(mtmL, m)
            mtmC := m
 
if not na(mtmC)
    prevMtm := mtmC
 
// ═════════════ PLOTS ═════════════
color cCol = mtmC >= mtmO ? #26a69a : #ef5350
plotcandle(mtmO, mtmH, mtmL, mtmC, "Net MTM (₹)", color = cCol, wickcolor = cCol, bordercolor = cCol)
hline(0, "Zero", color = #787b86, linestyle = hline.style_dotted)
plotshape(evEN, "Entry", shape.triangleup, location.bottom, #2962ff, size = size.tiny)
plotshape(evSL, "SL hit", shape.xcross, location.top, #ef5350, size = size.tiny)
plotshape(evRE, "Re-entry", shape.circle, location.top, #ff9800, size = size.tiny)
plotshape(evEX, "Position exit", shape.square, location.bottom, #9c27b0, size = size.tiny)
plot(mtmC, "Net MTM", display = display.data_window)
 
// ═════════════ GREEKS (Black-Scholes, IV implied from each leg's premium) ═════════════
f_ncdf(float x) =>
    float k = 1.0 / (1.0 + 0.2316419 * math.abs(x))
    float d = 0.3989422804014327 * math.exp(-x * x / 2.0)
    float p = d * k * (0.319381530 + k * (-0.356563782 + k * (1.781477937 + k * (-1.821255978 + k * 1.330274429))))
    x >= 0 ? 1.0 - p : p
 
f_npdf(float x) =>
    0.3989422804014327 * math.exp(-x * x / 2.0)
 
f_bs(float S, float K, float T, float r, float v, bool isCall) =>
    float sq = math.sqrt(T)
    float d1 = (math.log(S / K) + (r + v * v / 2) * T) / (v * sq)
    float d2 = d1 - v * sq
    isCall ? S * f_ncdf(d1) - K * math.exp(-r * T) * f_ncdf(d2) : K * math.exp(-r * T) * f_ncdf(-d2) - S * f_ncdf(-d1)
 
f_iv(float px, float S, float K, float T, float r, bool isCall) =>
    float lo = 0.01
    float hi = 3.0
    for j = 0 to 50
        float mid = (lo + hi) / 2
        if f_bs(S, K, T, r, mid, isCall) > px
            hi := mid
        else
            lo := mid
    (lo + hi) / 2
 
f_greeks(float S, float K, float T, float r, float v, bool isCall) =>
    float sq = math.sqrt(T)
    float d1 = (math.log(S / K) + (r + v * v / 2) * T) / (v * sq)
    float d2 = d1 - v * sq
    float delta = isCall ? f_ncdf(d1) : f_ncdf(d1) - 1
    float vega  = S * f_npdf(d1) * sq / 100
    float base  = -S * f_npdf(d1) * v / (2 * sq)
    float th    = isCall ? base - r * K * math.exp(-r * T) * f_ncdf(d2) : base + r * K * math.exp(-r * T) * f_ncdf(-d2)
    [delta, th / 365, vega]
 
f_payoff(float S) =>
    float pnl = 0.0
    for lg in legs
        if lg.on and lg.state > 0
            pnl += lg.realized - lg.charges
            if lg.state == 1 and not na(lg.strike)
                float intr = lg.optType == "C" ? math.max(S - lg.strike, 0) : math.max(lg.strike - S, 0)
                pnl += lg.side * (intr - lg.entry) * lg.qty
    pnl
 
// ═════════════ TABLE & PRICE-CHART DRAWINGS ═════════════
pos = tblPos == "Top right" ? position.top_right : tblPos == "Bottom right" ? position.bottom_right : tblPos == "Top left" ? position.top_left : position.bottom_left
var table tb = table.new(pos, 9, 32, bgcolor = #131722, frame_color = #2962ff, frame_width = 1, border_color = #2a2e39, border_width = 1)
var array<line>  dLines = array.new<line>()
var array<label> dLabs  = array.new<label>()
 
f_row(table t, int r, string k, string v, color vc) =>
    t.cell(0, r, k, text_color = #b2b5be, text_halign = text.align_left, text_size = size.small)
    t.cell(4, r, v, text_color = vc, text_halign = text.align_right, text_size = size.small)
    t.merge_cells(0, r, 3, r)
    t.merge_cells(4, r, 8, r)
 
if barstate.islast
    for ln in dLines
        ln.delete()
    dLines.clear()
    for lb in dLabs
        lb.delete()
    dLabs.clear()
 
    tb.clear(0, 0, 8, 31)
    int r = 0
    tb.cell(0, r, "POSITION P&L · " + syminfo.ticker, bgcolor = #2962ff, text_color = color.white, text_size = size.small)
    tb.merge_cells(0, r, 8, r)
    r += 1
    array<string> hdr = array.from("Leg", "Side", "Qty", "Entry", "LTP", "SL", "Status", "Re", "P&L")
    for c = 0 to 8
        tb.cell(c, r, hdr.get(c), bgcolor = #1e222d, text_color = #b2b5be, text_size = size.small)
    r += 1
 
    float S       = close
    float tot     = 0.0
    float chg     = 0.0
    float decay   = 0.0
    bool  anyLeg  = false
    bool  anyOpen = false
    bool  parsed  = true
    for lg in legs
        if lg.on
            anyLeg := true
            float lp = lg.realized - lg.charges + (lg.state == 1 ? lg.side * (lg.last - lg.entry) * lg.qty : 0.0)
            tot += lp
            chg += lg.charges
            if lg.state == 1
                anyOpen := true
                parsed := parsed and not na(lg.strike)
                decay -= lg.side * lg.last * lg.qty
            string stTxt = lg.state == 0 ? "Waiting" : lg.state == 1 ? "Open" : lg.state == 2 ? "SL · re-entry armed" : "Closed"
            color  stCol = lg.state == 1 ? #26a69a : lg.state == 2 ? #ff9800 : #787b86
            tb.cell(0, r, lg.name, text_color = color.white, text_size = size.small)
            tb.cell(1, r, lg.side > 0 ? "BUY" : "SELL", text_color = lg.side > 0 ? #26a69a : #ef5350, text_size = size.small)
            tb.cell(2, r, str.tostring(lg.qty, "#"), text_color = color.white, text_size = size.small)
            tb.cell(3, r, na(lg.entry) ? "—" : str.tostring(lg.entry, "#.##"), text_color = color.white, text_size = size.small)
            tb.cell(4, r, na(lg.last) ? "—" : str.tostring(lg.last, "#.##"), text_color = color.white, text_size = size.small)
            tb.cell(5, r, na(lg.sl) or lg.state != 1 ? "—" : str.tostring(lg.sl, "#.##"), text_color = #ff9800, text_size = size.small)
            tb.cell(6, r, stTxt, text_color = stCol, text_size = size.small)
            tb.cell(7, r, str.tostring(lg.reCount), text_color = color.white, text_size = size.small)
            tb.cell(8, r, lg.state == 0 ? "—" : f_rs(lp), text_color = lp >= 0 ? #26a69a : #ef5350, text_size = size.small)
            r += 1
 
    if not anyLeg
        tb.cell(0, r, "Pick at least one option contract in the settings (Leg 1 to Leg 4).", text_color = #ff9800, text_size = size.small)
        tb.merge_cells(0, r, 8, r)
        r += 1
    else
        string stat = posDone ? "Exited · " + exitWhy : anyOpen ? "Live" : "Waiting for entry"
        f_row(tb, r, "Position", stat, posDone ? #9c27b0 : anyOpen ? #26a69a : #787b86)
        r += 1
        f_row(tb, r, "Net P&L (after charges)", f_rs(tot), tot >= 0 ? #26a69a : #ef5350)
        r += 1
        f_row(tb, r, "Charges so far", "₹" + str.tostring(chg, "#,##0"), color.white)
        r += 1
        if decay != 0
            f_row(tb, r, decay > 0 ? "Net credit left to decay" : "Net debit at risk", "₹" + str.tostring(math.abs(decay), "#,##0"), color.white)
            r += 1
        if lkOn and not na(lockFloor)
            f_row(tb, r, "Profit locked at", f_rs(lockFloor), #26a69a)
            r += 1
 
        if showGreek and anyOpen
            float nD = 0.0
            float nT = 0.0
            float nV = 0.0
            bool  gOk = false
            for lg in legs
                if lg.on and lg.state == 1 and not na(lg.strike) and not na(lg.expiry)
                    float T = (lg.expiry - time_close) / 31536000000.0
                    if T > 0 and lg.last > 0 and S > 0
                        bool  isC = lg.optType == "C"
                        float iv  = f_iv(lg.last, S, lg.strike, T, rRate / 100, isC)
                        [d, th, vg] = f_greeks(S, lg.strike, T, rRate / 100, iv, isC)
                        nD += lg.side * lg.qty * d
                        nT += lg.side * lg.qty * th
                        nV += lg.side * lg.qty * vg
                        gOk := true
            if gOk
                f_row(tb, r, "Net delta", str.tostring(nD, "+#,##0;-#,##0") + " units (" + str.tostring(nD / lotSize, "+0.00;-0.00") + " lots)", color.white)
                r += 1
                f_row(tb, r, "Theta per day", f_rs(nT), nT >= 0 ? #26a69a : #ef5350)
                r += 1
                f_row(tb, r, "Vega per 1 IV point", f_rs(nV), color.white)
                r += 1
 
        if showPay and anyOpen and parsed and S > 0
            float lo = S * (1 - payRange / 100)
            float hi = S * (1 + payRange / 100)
            array<float> knots = array.from(lo, hi)
            for lg in legs
                if lg.on and lg.state == 1 and lg.strike > lo and lg.strike < hi
                    knots.push(lg.strike)
            knots.sort()
            float pS = knots.get(0)
            float pV = f_payoff(pS)
            float vMax = pV
            float vMin = pV
            array<float> bes = array.new_float()
            for j = 1 to knots.size() - 1
                float sx = knots.get(j)
                float v  = f_payoff(sx)
                vMax := math.max(vMax, v)
                vMin := math.min(vMin, v)
                if (pV < 0 and v >= 0) or (pV >= 0 and v < 0)
                    bes.push(pS - pV * (sx - pS) / (v - pV))
                pS := sx
                pV := v
            string beTxt = ""
            for be in bes
                beTxt += (beTxt == "" ? "" : " · ") + str.tostring(be, "#,##0")
                dLines.push(line.new(bar_index - 1, be, bar_index, be, extend = extend.both, color = #ff9800, style = line.style_dashed, width = 1, force_overlay = true))
                dLabs.push(label.new(bar_index + 3, be, "BE " + str.tostring(be, "#,##0"), style = label.style_label_left, color = #ff9800, textcolor = color.black, size = size.small, force_overlay = true))
            f_row(tb, r, "Expiry breakevens", beTxt == "" ? "none in range" : beTxt, #ff9800)
            r += 1
            f_row(tb, r, "Max profit / loss at expiry (±" + str.tostring(payRange) + "%)", f_rs(vMax) + " / " + f_rs(vMin), color.white)
            r += 1
            for lg in legs
                if lg.on and lg.state == 1 and lg.side < 0 and not na(lg.strike)
                    dLines.push(line.new(bar_index - 1, lg.strike, bar_index, lg.strike, extend = extend.both, color = #ef5350, style = line.style_dotted, width = 1, force_overlay = true))
                    dLabs.push(label.new(bar_index + 3, lg.strike, "Short " + lg.name, style = label.style_label_left, color = #ef5350, textcolor = color.white, size = size.small, force_overlay = true))
 
        if logN > 0 and evLog.size() > 0
            tb.cell(0, r, "EVENTS", bgcolor = #1e222d, text_color = #b2b5be, text_size = size.small)
            tb.merge_cells(0, r, 8, r)
            r += 1
            for j = 0 to math.min(logN, evLog.size()) - 1
                tb.cell(0, r, evLog.get(j), text_color = color.white, text_halign = text.align_left, text_size = size.small)
                tb.merge_cells(0, r, 8, r)
                r += 1
 
    tb.cell(0, r, "Calculated from market data · simulated fills, not broker P&L · educational tool", text_color = #787b86, text_size = size.tiny)
    tb.merge_cells(0, r, 8, r)

← 返回列表