Almazov Trade: London Breakout

Algorithms_ATS · study · 348 行 · 点赞 332 · TradingView 原页

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

Pine Script

// This Pine Script™ code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © Algorithms_ATS 
 
//@version=6
indicator("Almazov Trade: London Breakout", overlay = true, scale = scale.none, max_boxes_count = 500, max_lines_count = 500, max_labels_count = 500)
 
string ui_language = input.string("English", "Language / Язык", options = ["English", "Русский"], group = "Language / Язык", display = display.none)
bool use_ru = ui_language == "Русский"
tr(string en, string ru) =>
    use_ru ? ru : en
 
bool weekdays_only = input.bool(true, "Monday–Friday only / Только понедельник–пятница", group = "Session / Сессия", display = display.none)
int signal_end_hour = input.int(15, "Signal window ends: London hour / Конец поиска: час по Лондону", minval = 9, maxval = 23, group = "Session / Сессия", display = display.none)
color range_color = input.color(#597FC4, "Range color / Цвет диапазона", group = "Asian Range / Ночной диапазон", display = display.none)
int fill_transparency = input.int(94, "Range transparency / Прозрачность диапазона", minval = 0, maxval = 100, group = "Asian Range / Ночной диапазон", display = display.none)
int border_width = input.int(2, "Border width / Толщина рамки", minval = 1, maxval = 4, group = "Asian Range / Ночной диапазон", display = display.none)
int level_width = input.int(2, "Level width / Толщина уровней", minval = 1, maxval = 4, group = "Asian Range / Ночной диапазон", display = display.none)
bool show_range_caption = input.bool(true, "Range caption / Подпись диапазона", group = "Asian Range / Ночной диапазон", display = display.none)
int session_history = input.int(30, "Sessions on chart / Сессий на графике", minval = 1, maxval = 40, group = "Asian Range / Ночной диапазон", display = display.none)
bool use_distance_filter = input.bool(true, "Limit distance from breakout boundary / Ограничить расстояние от границы пробоя", group = "Signals / Сигналы", display = display.none)
float max_entry_distance_pct = input.float(25.0, "Maximum entry distance, % of range / Максимальное расстояние входа, % диапазона", minval = 0, maxval = 1000, step = 1, group = "Signals / Сигналы", tooltip = "Distance from the broken boundary to the 15-minute confirmation close, divided by Asian range width. 25% permits an entry up to one quarter of the range beyond its boundary. If too far, wait for a later eligible close within the London entry window. Disable the checkbox to ignore this limit. / Расстояние от пробитой границы до закрытия подтверждающей 15-минутной свечи относительно ширины Азии. 25% разрешает вход не дальше четверти диапазона за границей. Если цена слишком далеко, ждём следующего подходящего закрытия в окне Лондона. Снимите галочку, чтобы отключить ограничение.", display = display.none)
color long_color = input.color(#00C878, "LONG color / Цвет LONG", group = "Signals / Сигналы", display = display.none)
color short_color = input.color(#E64646, "SHORT color / Цвет SHORT", group = "Signals / Сигналы", display = display.none)
bool highlight_signal = input.bool(true, "Highlight entry candle / Подсвечивать свечу входа", group = "Signals / Сигналы", display = display.none)
bool show_signal_labels = input.bool(true, "Entry labels / Метки входа", group = "Signals / Сигналы", display = display.none)
bool show_entry_marker = input.bool(true, "Entry point / Точка входа", group = "Signals / Сигналы", display = display.none)
bool show_london_window = input.bool(true, "London entry window / Окно входов Лондона", group = "Session / Сессия", display = display.none)
color london_color = input.color(#C29A56, "London color / Цвет Лондона", group = "Session / Сессия", display = display.none)
float max_stop_pct = input.float(15.0, "Maximum stop, % of entry price / Максимальный стоп, % цены входа", minval = 0.1, maxval = 99.9, step = 0.1, group = "Trades / Сделки", tooltip = "LONG: entry × (1 − % / 100). SHORT: entry × (1 + % / 100). Price movement, without leverage. The level is fixed at entry. A gap through the stop is recorded at the opening price, so the realized loss can exceed this threshold. / LONG: вход × (1 − % / 100). SHORT: вход × (1 + % / 100). Движение цены без учёта плеча. Уровень фиксируется при входе. При гэпе через стоп учитывается цена открытия, поэтому фактический убыток может превысить порог.", display = display.none)
bool show_trade_grid = input.bool(true, "Entry and result zone / Вход и зона результата", group = "Trades / Сделки", display = display.none)
bool show_price_tags = input.bool(true, "Active trade price tags / Ценники открытой сделки", group = "Trades / Сделки", display = display.none)
int projection = input.int(5, "Extend trade levels, bars / Продление уровней сделки, баров", minval = 1, maxval = 30, group = "Trades / Сделки", display = display.none)
int trade_history = input.int(40, "Trades on chart / Сделок на графике", minval = 1, maxval = 40, group = "Trades / Сделки", display = display.none)
color risk_color = input.color(#DC4155, "Loss color / Цвет убытка", group = "Trades / Сделки", display = display.none)
color reward_color = input.color(#00A078, "Reward color / Цвет прибыли", group = "Trades / Сделки", display = display.none)
color entry_color = input.color(#8897AB, "Entry color / Цвет входа", group = "Trades / Сделки", display = display.none)
int zone_transparency = input.int(88, "Zone transparency / Прозрачность зон", minval = 0, maxval = 100, group = "Trades / Сделки", display = display.none)
bool show_table = input.bool(true, "Statistics / Статистика", group = "Table / Таблица", display = display.none)
int table_font = input.int(12, "Font size / Размер шрифта", minval = 9, maxval = 18, group = "Table / Таблица", display = display.none)
 
string london = "Europe/London"
int bar_ms = int(timeframe.in_seconds() * 1000)
if barstate.isfirst
    if not timeframe.isminutes
        runtime.error(tr("Use a standard minute chart.", "Используйте стандартный минутный график."))
    if timeframe.multiplier > 15 or 15 % timeframe.multiplier != 0
        runtime.error(tr("Supported chart timeframes: 1, 3, 5 or 15 minutes. Entries always use 15-minute closes.", "Таймфреймы графика: 1, 3, 5 или 15 минут. Входы всегда по закрытию 15-минутных свечей."))
    if not chart.is_standard
        runtime.error(tr("Use standard OHLC candles.", "Используйте обычные свечи OHLC."))
price_text(float value) =>
    str.tostring(value, format.mintick)
type mysession
    box area
    line high_line
    line low_line
    label caption
    label london_caption
    line london_open
type mytrade
    int direction
    int entry_bar
    int asia_deadline
    float entry
    float max_stop
    line entry_line
    line result_line
    box result_box
    label entry_label
    label exit_label
var array<mysession> sessions = array.new<mysession>()
var array<mytrade> trades = array.new<mytrade>()
var array<label> price_tags = array.new<label>()
var mysession current_session = na
var mytrade active_trade = na
delete_session(mysession w) =>
    box.delete(w.area)
    line.delete(w.high_line)
    line.delete(w.low_line)
    label.delete(w.caption)
    label.delete(w.london_caption)
    line.delete(w.london_open)
    0
delete_trade(mytrade w) =>
    line.delete(w.entry_line)
    line.delete(w.result_line)
    box.delete(w.result_box)
    label.delete(w.entry_label)
    label.delete(w.exit_label)
    0
clear_tags() =>
    while price_tags.size() > 0
        label.delete(price_tags.pop())
    0
update_trade(mytrade w, int right_time, float mark_price) =>
    color result_color = w.direction * (mark_price - w.entry) >= 0 ? reward_color : risk_color
    if not na(w.entry_line)
        w.entry_line.set_x2(right_time)
        w.result_line.set_x2(right_time)
        w.result_line.set_y1(mark_price)
        w.result_line.set_y2(mark_price)
        w.result_line.set_color(result_color)
    if not na(w.result_box)
        w.result_box.set_right(right_time)
        w.result_box.set_top(math.max(w.entry, mark_price))
        w.result_box.set_bottom(math.min(w.entry, mark_price))
        w.result_box.set_bgcolor(color.new(result_color, zone_transparency))
    0
make_tag(int at_time, float price, string caption, color col) =>
    label.new(x = at_time, y = price, text = caption + "  " + price_text(price), xloc = xloc.bar_time, style = label.style_label_left, color = col, textcolor = color.white, size = size.small, force_overlay = true)
 
get_breakout(float hg, float lw, float cl) =>
    int direction = cl > hg ? 1 : cl < lw ? -1 : 0
    direction
allow_entry_distance(int d, float hg, float lw, float cl, bool enabled, float max_pct) =>
    float width = hg - lw
    float distance = d == 1 ? cl - hg : lw - cl
    bool allowed = not enabled or width > 0 and distance >= 0 and distance <= width * max_pct / 100
    allowed
get_max_stop(int d, float entry, float pct, float tick) =>
    float raw_stop = entry * (1 - d * pct / 100)
    float stop = d == 1 ? math.ceil(raw_stop / tick - 0.000000001) * tick : math.floor(raw_stop / tick + 0.000000001) * tick
    stop
resolve_max_stop(int d, float sl, float op, float hg, float lw) =>
    bool hit = false
    float fill = na
    if d * (op - sl) <= 0
        hit := true
        fill := op
    else if d == 1 ? lw <= sl : hg >= sl
        hit := true
        fill := sl
    [hit, fill]
get_timed_exit(int deadline, int bar_open, int bar_close, float op, float cl) =>
    bool expired = bar_close >= deadline
    float fill = na
    if expired
        fill := bar_open >= deadline ? op : cl
    [expired, fill]
get_result_sign(int d, float entry, float fill) =>
    float movement = d * (fill - entry)
    int result = movement > 0 ? 1 : movement < 0 ? -1 : 0
    result
int ly = year(time, london)
int lm = month(time, london)
int ld = dayofmonth(time, london)
int weekday = dayofweek(time, london)
int range_start = timestamp(london, ly, lm, ld, 0, 0)
int range_end = timestamp(london, ly, lm, ld, 8, 0)
int window_end = timestamp(london, ly, lm, ld, signal_end_hour, 0)
bool allowed_day = not weekdays_only or weekday >= dayofweek.monday and weekday <= dayofweek.friday
bool in_range = allowed_day and time >= range_start and time < range_end
bool range_starts = in_range and (not in_range[1] or range_start != range_start[1])
int day_key = ly * 10000 + lm * 100 + ld
bool new_day = barstate.isfirst or day_key != day_key[1]
bool in_window = allowed_day and time >= range_end and time_close <= window_end
bool signal_close = time_close == time_close("15")
int signal_start = time("15")
var int signal_expected = na
var bool signal_complete = false
var float range_high = na
var float range_low = na
var bool range_complete = false
var bool range_ready = false
var int range_bar_count = 0
var int expected_time = na
var bool day_used = false
var int range_day = na
var int closed_trades = 0
var int winning_trades = 0
var int losing_trades = 0
var float total_percent = 0.0
bool long_entry_signal = false
bool short_entry_signal = false
bool take_profit_exit = false
bool stop_loss_exit = false
bool trade_closed_this_bar = false
bool asia_close_exit = false
bool max_stop_exit = false
 
if barstate.isconfirmed
    if new_day
        range_ready := false
        range_complete := false
        range_bar_count := 0
        day_used := false
        range_high := na
        range_low := na
        expected_time := range_start
    if signal_start != signal_start[1] or barstate.isfirst
        signal_complete := time == signal_start
        signal_expected := signal_start
    signal_complete := signal_complete and time == signal_expected and time_close - time == bar_ms
    signal_expected := time_close
    if range_starts
        if not na(current_session)
            if not na(current_session.high_line)
                current_session.high_line.set_extend(extend.none)
                current_session.high_line.set_x2(range_end)
                current_session.low_line.set_extend(extend.none)
                current_session.low_line.set_x2(range_end)
        range_high := na
        range_low := na
        range_ready := false
        range_complete := time == range_start
        range_bar_count := 0
        expected_time := range_start
        day_used := false
        range_day := day_key
        current_session := mysession.new()
        if range_complete
            current_session.area := box.new(left = range_start, top = high, right = time_close, bottom = low, xloc = xloc.bar_time, border_color = range_color, border_width = border_width, bgcolor = color.new(range_color, fill_transparency), force_overlay = true)
        sessions.push(current_session)
        if sessions.size() > session_history
            delete_session(sessions.shift())
    if in_range and range_complete
        bool aligned = time == expected_time and time_close - time == bar_ms and time_close <= range_end
        range_complete := aligned
        if aligned
            range_bar_count += 1
            expected_time := time_close
            range_high := na(range_high) ? high : math.max(range_high, high)
            range_low := na(range_low) ? low : math.min(range_low, low)
            current_session.area.set_top(range_high)
            current_session.area.set_bottom(range_low)
            current_session.area.set_right(time_close)
            if time_close == range_end
                range_ready := range_bar_count == int((range_end - range_start) / bar_ms) and range_high > range_low
                if range_ready
                    current_session.high_line := line.new(x1 = range_end, y1 = range_high, x2 = range_end + bar_ms, y2 = range_high, xloc = xloc.bar_time, extend = extend.right, color = range_color, width = level_width, force_overlay = true)
                    current_session.low_line := line.new(x1 = range_end, y1 = range_low, x2 = range_end + bar_ms, y2 = range_low, xloc = xloc.bar_time, extend = extend.right, color = range_color, width = level_width, force_overlay = true)
                    if show_london_window
                        current_session.london_open := line.new(x1 = range_end, y1 = range_low, x2 = range_end, y2 = range_high, xloc = xloc.bar_time, color = color.new(london_color, 35), style = line.style_dashed, width = 1, force_overlay = true)
                        current_session.london_caption := label.new(x = int((range_end + window_end) / 2), y = range_high + (range_high - range_low) * 0.05, text = tr("LONDON · 08:00–", "ЛОНДОН · 08:00–") + str.tostring(signal_end_hour, "00") + ":00", xloc = xloc.bar_time, style = label.style_label_down, color = color.new(london_color, 18), textcolor = #17202D, size = size.tiny, force_overlay = true)
                    if show_range_caption
                        float caption_price = range_high + (range_high - range_low) * 0.05
                        current_session.caption := label.new(x = int((range_start + range_end) / 2), y = caption_price, text = tr("ASIAN RANGE · ", "НОЧНОЙ ДИАПАЗОН · ") + str.format_time(range_start, "dd.MM", london) + "\n00:00–08:00", xloc = xloc.bar_time, style = label.style_label_down, color = color.new(range_color, 12), textcolor = color.white, size = size.tiny, force_overlay = true)
                else
                    box.delete(current_session.area)
                    current_session.area := na
        else
            box.delete(current_session.area)
            current_session.area := na
    if not na(active_trade) and bar_index > active_trade.entry_bar
        mytrade w = active_trade
        [deadline_reached, time_fill] = get_timed_exit(w.asia_deadline, time, time_close, open, close)
        [stop_reached, stop_fill] = resolve_max_stop(w.direction, w.max_stop, open, high, low)
        bool overdue_at_open = time >= w.asia_deadline
        bool exit_now = deadline_reached or stop_reached
        bool stopped = stop_reached and not overdue_at_open
        float exit_price = stopped ? stop_fill : time_fill
        if exit_now
            int exit_time = stopped ? time : overdue_at_open ? time : time_close
            int exit_reason = get_result_sign(w.direction, w.entry, exit_price)
            stop_loss_exit := exit_reason < 0
            take_profit_exit := exit_reason > 0
            asia_close_exit := not stopped
            max_stop_exit := stopped
            trade_closed_this_bar := true
            float result_percent = w.direction * (exit_price - w.entry) / w.entry * 100.0
            closed_trades += 1
            total_percent += result_percent
            if exit_reason < 0
                losing_trades += 1
            else if exit_reason > 0
                winning_trades += 1
            update_trade(w, exit_time, exit_price)
            bool label_below = exit_price <= w.entry
            w.exit_label := label.new(x = exit_time, y = exit_price, text = (exit_reason == 0 ? tr("BE", "БУ") : exit_reason < 0 ? tr("SL", "СТОП") : tr("TP", "ТЕЙК")) + " · " + (result_percent > 0 ? "+" : "") + str.tostring(result_percent, "0.00") + "%", xloc = xloc.bar_time, style = label_below ? label.style_label_up : label.style_label_down, color = exit_reason == 0 ? #66788F : exit_reason < 0 ? risk_color : reward_color, textcolor = color.white, size = size.small, tooltip = (stopped ? tr("Maximum percentage stop reached\n", "Достигнут максимальный стоп в процентах\n") : tr("Closed before next Asian session\n", "Закрыто перед следующей Азией\n")) + tr("Exit: ", "Выход: ") + price_text(exit_price) + "\n" + str.format_time(exit_time, "dd.MM HH:mm", london) + (overdue_at_open and not stopped ? tr("\nSession boundary missing: first available open.", "\nНа границе нет данных: первое доступное открытие.") : ""), force_overlay = true)
            clear_tags()
            active_trade := na
    bool can_search = range_ready and range_day == day_key and in_window and signal_close and signal_complete and not day_used and na(active_trade) and not trade_closed_this_bar
    if can_search
        int direction = get_breakout(range_high, range_low, close)
        if direction != 0 and allow_entry_distance(direction, range_high, range_low, close, use_distance_filter, max_entry_distance_pct)
            float entry = close
            mytrade w = mytrade.new()
            w.direction := direction
            w.entry_bar := bar_index
            int next_asia_offset = weekdays_only and weekday == dayofweek.friday ? 3 : weekdays_only and weekday == dayofweek.saturday ? 2 : 1
            w.asia_deadline := timestamp(london, ly, lm, ld + next_asia_offset, 0, 0)
            w.entry := entry
            w.max_stop := get_max_stop(direction, entry, max_stop_pct, syminfo.mintick)
            int right_time = time_close + projection * bar_ms
            color signal_color = direction == 1 ? long_color : short_color
            if show_signal_labels
                w.entry_label := label.new(x = time, y = direction == 1 ? low : high, text = (direction == 1 ? tr("LONG", "ЛОНГ") : tr("SHORT", "ШОРТ")), xloc = xloc.bar_time, style = direction == 1 ? label.style_label_up : label.style_label_down, color = signal_color, textcolor = color.white, size = size.small, tooltip = tr("15-minute confirmation close: ", "Закрытие подтверждающей 15-минутной свечи: ") + price_text(entry) + "\n" + str.format_time(time_close, "dd.MM HH:mm", london) + "\n" + tr("Maximum stop: ", "Максимальный стоп: ") + price_text(w.max_stop) + " (" + str.tostring(max_stop_pct, "0.0") + "%)", force_overlay = true)
            if show_trade_grid
                w.result_box := box.new(left = time_close, top = entry, right = right_time, bottom = entry, xloc = xloc.bar_time, border_color = na, bgcolor = color.new(reward_color, zone_transparency), force_overlay = true)
                w.entry_line := line.new(x1 = time_close, y1 = entry, x2 = right_time, y2 = entry, xloc = xloc.bar_time, color = entry_color, width = 2, force_overlay = true)
                w.result_line := line.new(x1 = time_close, y1 = entry, x2 = right_time, y2 = entry, xloc = xloc.bar_time, color = reward_color, width = 1, style = line.style_dotted, force_overlay = true)
            clear_tags()
            if show_trade_grid and show_price_tags
                price_tags.push(make_tag(right_time, entry, tr("Entry", "Вход"), #26384F))
            trades.push(w)
            if trades.size() > trade_history
                delete_trade(trades.shift())
            active_trade := w
            day_used := true
            long_entry_signal := direction == 1
            short_entry_signal := direction == -1
 
if not na(active_trade)
    mytrade w = active_trade
    int right_time = time_close + projection * bar_ms
    update_trade(w, right_time, close)
    if price_tags.size() == 1
        price_tags.get(0).set_x(right_time)
 
bgcolor(show_london_window and in_window ? color.new(london_color, 96) : na, title = "London entry window / Окно входов Лондона", force_overlay = true)
color signal_bar_color = long_entry_signal ? long_color : short_entry_signal ? short_color : na
barcolor(highlight_signal ? signal_bar_color : na)
plotshape(show_entry_marker and long_entry_signal ? close : na, title = "LONG entry / Вход LONG", style = shape.circle, location = location.absolute, color = long_color, size = size.tiny, display = display.pane, force_overlay = true)
plotshape(show_entry_marker and short_entry_signal ? close : na, title = "SHORT entry / Вход SHORT", style = shape.circle, location = location.absolute, color = short_color, size = size.tiny, display = display.pane, force_overlay = true)
color panel_bg = #101720
color panel_header = #1A2635
color panel_alternate = #141E2A
color panel_text = #E4EAF2
color panel_muted = #A3B1C2
color panel_accent = #B7CBE3
var table stats_table = table.new(position.top_right, 2, 7, bgcolor = panel_bg, frame_color = #35465B, frame_width = 1, border_width = 0)
stat_row(int row, string caption, string value, color value_color) =>
    color row_bg = row % 2 == 0 ? panel_alternate : panel_bg
    table.cell(stats_table, 0, row, caption, text_color = panel_muted, bgcolor = row_bg, text_size = table_font, text_halign = text.align_left)
    table.cell(stats_table, 1, row, value, text_color = value_color, bgcolor = row_bg, text_size = table_font, text_halign = text.align_right)
if barstate.isfirst
    stats_table.merge_cells(0, 6, 1, 6)
float win_rate = closed_trades > 0 ? winning_trades * 100.0 / closed_trades : na
if barstate.islast
    if show_table
        table.cell(stats_table, 0, 0, tr("STATISTICS", "СТАТИСТИКА"), text_color = panel_accent, bgcolor = panel_header, text_size = table_font - 1, text_halign = text.align_left, text_formatting = text.format_bold)
        table.cell(stats_table, 1, 0, tr("RESULT", "РЕЗУЛЬТАТ"), text_color = panel_accent, bgcolor = panel_header, text_size = table_font - 1, text_halign = text.align_right, text_formatting = text.format_bold)
        stat_row(1, tr("Closed trades", "Закрытые сделки"), str.tostring(closed_trades), panel_text)
        stat_row(2, tr("Winning trades", "Прибыльные сделки"), str.tostring(winning_trades), reward_color)
        stat_row(3, tr("Losing trades", "Убыточные сделки"), str.tostring(losing_trades), risk_color)
        stat_row(4, tr("Win rate", "Доля прибыльных"), closed_trades > 0 ? str.tostring(win_rate, "0.00") + "%" : "—", panel_text)
        stat_row(5, tr("Sum of returns", "Сумма доходностей"), (total_percent > 0 ? "+" : "") + str.tostring(total_percent, "0.00") + "%", total_percent >= 0 ? reward_color : risk_color)
        table.cell(stats_table, 0, 6, tr("Asia / max stop · sum without compounding or costs", "Азия / макс. стоп · сумма без реинвестирования и издержек"), text_color = panel_muted, bgcolor = panel_header, text_size = table_font - 2, text_halign = text.align_left)
 
    else
        table.clear(stats_table, 0, 0, 1, 6)
alertcondition(long_entry_signal, title = "London Breakout LONG / ЛОНГ", message = "Almazov Trade: London Breakout | LONG | {{ticker}} | {{interval}}")
alertcondition(short_entry_signal, title = "London Breakout SHORT / ШОРТ", message = "Almazov Trade: London Breakout | SHORT | {{ticker}} | {{interval}}")
alertcondition(take_profit_exit, title = "London Breakout TP / Тейк", message = "Almazov Trade: London Breakout | TP | {{ticker}} | {{interval}}")
alertcondition(stop_loss_exit, title = "London Breakout SL / Стоп", message = "Almazov Trade: London Breakout | SL | {{ticker}} | {{interval}}")
 
alertcondition(asia_close_exit, title = "London Breakout: close before Asia / Закрытие перед Азией", message = "Almazov Trade: London Breakout | Close before Asia / Закрытие перед Азией | {{ticker}} | {{interval}}")
 
alertcondition(max_stop_exit, title = "London Breakout: maximum stop / Максимальный стоп", message = "Almazov Trade: London Breakout | Maximum percentage stop / Максимальный стоп в процентах | {{ticker}} | {{interval}}")

← 返回列表