I will code your EAs and Indicators for no charge

What do you think about using a Bollinger Band filter instead of RSI? For example, it would signal on a narrow band right before a breakout.

Do traders still buy indicators?

I have no idea, I don't sell indicators.
However, knowing the naivety of people, I susspect they still do...
There isn't much recent data available:
https://chatgpt.com/share/6a0dac2d-a...9-c6586cf94300

I don't really care!
I already told you that this is not for me.
The only way for me is to manually find the "manipulation level" - no indicator can do that.
I already have:
1. ATS boxes,
2. Wyckoff Trading Range boxes,
3. KK/MQLTA breakout boxes (with my mods).
None of them can do what I need to see.
They can be close, sometimes even helpful to figure out what's going on in general, but not for actual swing trading.

For my style of trading, I need to see:
1. What the price is doing in the context of ADR, today (that's my market where I am looking for trades),
2. What the price is doing in the context of something like the EMA Channel MTF (for best entry points),
3. Then I need to see a manipulation by Market Makers, often described as False Breakout, or Upthrust and Shakeout (that's my trading range - that's where I plot my box).

All of the above indicators are basically attempts to codify the same idea, but it can't be codified.

PS. Most Smart Money Concepts, or ICT Traders use volumes to support their FBo hypothesis.
However, as we all know, MT4 does not provide volumes which would actually tell us how much sales against buys there actually is. All such indicators are based on tick volumes which don't carry any information about sells or buys.

PPS. So, all BuyersSellersDashboard.ex4 are just total BS - they do not, and can not actually show us anything real. They are only based on the fact if the candle or range was bullish or bearish...

MASTER BESTTRADER, you just described something that i consider the core of insightful trading strategy for serious people to be conversant in this forum. if you know that you are mostly stopped out, and of course you surely would, unless you study liquidity sweep and false breakout and positive breakout. that will change your perception about trading. some times i see some stuffs being that tends to pick trade in the middle of no where and i mean it. BESTTRADER help people who are groping by putting what you just described into a tool that will at least guide a person 50 percent of the journey to prevent early drowning. i can assure you that, the big boy will never enter without sweeping.

There is no special tool - you need to be able to read that from the chart.
The only tool is the Market Maker's Order Book - do you have access? I don't, so I need to see that the specific price move is potentially such a manipulation.
You are asking me to teach people, and yet all the teachings have already been provided!
Since the Dow Theory and Wyckoff - everything is there already!
I can not teach anybody anything if they don't do their part and learn!
And I can guarantee that even if someone already knows it all, and has read everything, they will still be losing if they are unable to figure out the psychological and emotional part of trading.
Also, all the tools have already been provided, either in this thread, or in countless other threads.

Hello esteemed coders. This indicator is part of a strategy I'm working on. It's causing problems generating new arrows during live trading. Could you please check and fix this? Thank you in advance.

High/Low OPEN signal. 100% no repaint!

So, what's the problem?
Can't your EA stop opening new orders when a position is floating?

Thank you very much, sagat1977. However, when I open both indicators on the platform, the arrows don't match even though the settings are the same. Why is that?

One triggers on an open candle, while the other original one triggers on a closed candle. The 'open' one is better, but you can change it to 'closed' in the settings menu.
High/Low To Closed

I haven't created an EA yet, sir. However, the arrow that should indicate the transaction isn't appearing. When I refresh the platform, the arrows appear as they should.

Yes, you're right. Now it's better.

who in this forum gives services for coding the strategy ?

I can, I have been coding my own for the last 6 months. Let me know if you want to talk about it.

You need to look in the Commercial segment, or go to jobs in MQL5.
https://www.forexfactory.com/userguide

I STILL CANT FIGURE OUT WHY THSI REPAINTS, EVEN WITH IT NATURE I HAVE FOUND USE IN IT,CAN ANYONE PLS HELP?

//+------------------------------------------------------------------+
//| TradeEntry2.mq5 |
//| v2.04 - Rolling stddev bands, no repaint, no delayed arrows |
//| |
//+------------------------------------------------------------------+
#property copyright "Copyright 2025, Built based on user specs"
#property version "2.04"
#property strict
#property indicator_chart_window
#property indicator_buffers 4
#property indicator_plots 0

enum ENUM_HISTOGRAM_LINE { Stochastic_2, Stochastic_1, RSI };

//--- Inputs: smTMMS
input ENUM_HISTOGRAM_LINE Histogram_Line = Stochastic_2;
input int RSI_Period = 14;
input ENUM_APPLIED_PRICE RSI_AppliedPrice = PRICE_CLOSE;
input int Stochastic_1_Period_K = 60;
input int Stochastic_1_Period_D = 900;
input int Stochastic_1_Slowing = 40;
input ENUM_STO_PRICE Stochastic_1_PriceField = STO_LOWHIGH;
input ENUM_MA_METHOD Stochastic_1_MAmethod = MODE_SMA;
input int Stochastic_2_Period_K = 5;
input int Stochastic_2_Period_D = 10;
input int Stochastic_2_Slowing = 10;
input ENUM_STO_PRICE Stochastic_2_PriceField = STO_LOWHIGH;
input ENUM_MA_METHOD Stochastic_2_MAmethod = MODE_SMA;

//--- Inputs: Point of Balance
input int Pob_Period = 19;
input int Pob_Level = 10;
input ENUM_APPLIED_PRICE Pob_Price = PRICE_CLOSE;

//--- Inputs: TMA1
input int TMA1_HalfLength = 100;
input ENUM_APPLIED_PRICE TMA1_Price = PRICE_WEIGHTED;
input double TMA1_BandsDeviations = 2.2;
input bool TMA1_RePaint = false; // WARNING: true = signals repaint

//--- Inputs: TMA2
input int TMA2_HalfLength = 56;
input ENUM_APPLIED_PRICE TMA2_Price = PRICE_WEIGHTED;
input double TMA2_BandsDeviations = 1.6;
input bool TMA2_RePaint = false; // WARNING: true = signals repaint

//--- Arrow offset
input int ArrowOffsetPoints = 30;

//--- Alerts
// Alerts fire on bar 1 (the confirmation candle) the moment the arrow is placed.
// Each alert type is individually toggleable.
input bool Alert_Popup = true; // MT5 alert popup
input bool Alert_Sound = true; // sound (uses MT5 default alert sound)
input bool Alert_Push = true; // push notification to mobile app
input bool Alert_Email = true; // email (configure SMTP in MT5 Tools > Options)

//--- Registered calculation buffers (4 slots, none plotted)
double TMABuf1[];
double TMABuf2[];
double PobPrices[];
double RSIBuf[];

//--- Working arrays — bar index always == array index
double sUpBuf1[], sDnBuf1[];
double sUpBuf2[], sDnBuf2[];
double sStoch1[], sStoch2[];
double MpAvg[][11];

//--- Handles
int rsiHandle = INVALID_HANDLE;
int stoch1Handle = INVALID_HANDLE;
int stoch2Handle = INVALID_HANDLE;

int PobLevel;
int prevRatesTotal = 0;
string tfStr = "";
const string cName = "TE2_";
datetime lastAlertTime = 0; // prevents firing duplicate alerts on the same bar

//+------------------------------------------------------------------+
string TFToString(ENUM_TIMEFRAMES tf)
{
switch(tf)
{
case PERIOD_M1: return("M1");
case PERIOD_M2: return("M2");
case PERIOD_M3: return("M3");
case PERIOD_M4: return("M4");
case PERIOD_M5: return("M5");
case PERIOD_M6: return("M6");
case PERIOD_M10: return("M10");
case PERIOD_M12: return("M12");
case PERIOD_M15: return("M15");
case PERIOD_M20: return("M20");
case PERIOD_M30: return("M30");
case PERIOD_H1: return("H1");
case PERIOD_H2: return("H2");
case PERIOD_H3: return("H3");
case PERIOD_H4: return("H4");
case PERIOD_H6: return("H6");
case PERIOD_H8: return("H8");
case PERIOD_H12: return("H12");
case PERIOD_D1: return("D1");
case PERIOD_W1: return("W1");
case PERIOD_MN1: return("MN1");
}
return("UNK");
}

//+------------------------------------------------------------------+
int OnInit()
{
PobLevel = MathMax(MathMin(Pob_Level, 10), 1);
tfStr = _Symbol + "_" + TFToString(PERIOD_CURRENT) + "_";

rsiHandle = iRSI(_Symbol, PERIOD_CURRENT, RSI_Period, RSI_AppliedPrice);
stoch1Handle = iStochastic(_Symbol, PERIOD_CURRENT,
Stochastic_1_Period_K, Stochastic_1_Period_D, Stochastic_1_Slowing,
Stochastic_1_MAmethod, Stochastic_1_PriceField);
stoch2Handle = iStochastic(_Symbol, PERIOD_CURRENT,
Stochastic_2_Period_K, Stochastic_2_Period_D, Stochastic_2_Slowing,
Stochastic_2_MAmethod, Stochastic_2_PriceField);

if(rsiHandle == INVALID_HANDLE ||
stoch1Handle == INVALID_HANDLE ||
stoch2Handle == INVALID_HANDLE)
{
Print("TradeEntry2: failed to create sub-indicator handles");
return(INIT_FAILED);
}

SetIndexBuffer(0, TMABuf1, INDICATOR_CALCULATIONS);
SetIndexBuffer(1, TMABuf2, INDICATOR_CALCULATIONS);
SetIndexBuffer(2, PobPrices, INDICATOR_CALCULATIONS);
SetIndexBuffer(3, RSIBuf, INDICATOR_CALCULATIONS);

string shortName = "TradeEntry2 v2.04";
if(TMA1_RePaint || TMA2_RePaint)
shortName += " [REPAINTS]";
IndicatorSetString(INDICATOR_SHORTNAME, shortName);

prevRatesTotal = 0;
return(INIT_SUCCEEDED);
}

//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
if(rsiHandle != INVALID_HANDLE) IndicatorRelease(rsiHandle);
if(stoch1Handle != INVALID_HANDLE) IndicatorRelease(stoch1Handle);
if(stoch2Handle != INVALID_HANDLE) IndicatorRelease(stoch2Handle);
DeleteTE2Objects();
}

//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
const int prev_calculated,
const datetime &time[],
const double &open[],
const double &high[],
const double &low[],
const double &close[],
const long &tick_volume[],
const long &volume[],
const int &spread[])
{
//--- Minimum bar guards
if(rates_total < 1500) return(0);
int minBars = (int)MathMax(
MathMax(Stochastic_1_Period_K + Stochastic_1_Period_D,
Stochastic_2_Period_K + Stochastic_2_Period_D),
RSI_Period) + 10;
if(rates_total < minBars) return(0);

//--- New bar detection
bool newBar = (rates_total != prevRatesTotal);
if(newBar) prevRatesTotal = rates_total;

//--- Full pass flag.
// Only needed on first load (prev_calculated==0) or indicator reset.
// With rolling stddev bands, each bar's upBuf/dnBuf depends ONLY on
// its own price window — NOT on rates_total. So incremental ticks are
// fully safe: bar 1 and bar 0 are recomputed; all older bars are stable.
// We deliberately do NOT force fullPass on newBar — doing so would
// refetch all stochastic history (which drifts) and re-evaluate all
// historical bars, which is the remaining source of repainting.
bool fullPass = (prev_calculated <= 0);

//--- Resize arrays when bar count changes.
// sWuBuf/sWdBuf removed — no longer needed now that bands use rolling stddev.
if(ArraySize(sStoch1) != rates_total)
{
ArrayResize(sStoch1, rates_total);
ArrayResize(sStoch2, rates_total);
ArrayResize(sUpBuf1, rates_total);
ArrayResize(sDnBuf1, rates_total);
ArrayResize(sUpBuf2, rates_total);
ArrayResize(sDnBuf2, rates_total);
}
if(ArrayRange(MpAvg, 0) != rates_total)
ArrayResize(MpAvg, rates_total);

//--- Copy indicator data.
// fullPass : all bars — every historical bar gets correct values.
// Incremental: bars 0, 1, and 2 — bar 2 is the TMA trigger bar when i=1.
// The signal at bar 1 reads sStoch1[1] for trend (bar just closed — must be fresh).
// Copying 3 bars guarantees every value the signal reads at bar 1 is current.
int copyCount = fullPass ? rates_total : MathMin(3, rates_total);

double rsi_raw[], st1_raw[], st2_raw[];
int rsiCopied = CopyBuffer(rsiHandle, 0, 0, copyCount, rsi_raw);
int st1Copied = CopyBuffer(stoch1Handle, 0, 0, copyCount, st1_raw);
int st2Copied = CopyBuffer(stoch2Handle, 0, 0, copyCount, st2_raw);

//--- On a fullPass we MUST have fresh data — abort if any CopyBuffer failed.
// On an incremental newBar tick, sStoch/RSIBuf still hold the previous
// tick's values which are valid for bar 1. Do NOT abort — proceed using
// cached arrays. This is the fix for "must switch TF before arrow appears":
// previously a CopyBuffer failure on the first newBar tick caused an early
// return, newBar became false on the next tick, and the signal loop never ran.
if(fullPass && (rsiCopied <= 0 || st1Copied <= 0 || st2Copied <= 0))
return(prev_calculated);

//--- Write freshly copied bars into persistent arrays.
// Only overwrite slots that were actually returned.
if(rsiCopied > 0 && st1Copied > 0 && st2Copied > 0)
{
int filled = MathMin(MathMin(rsiCopied, st1Copied), st2Copied);
for(int k = 0; k < filled; k++)
{
RSIBuf[k] = rsi_raw[k] - 50.0;
sStoch1[k] = st1_raw[k] - 50.0;
sStoch2[k] = st2_raw[k] - 50.0;
}
}

//--- TMA calculation.
// Rolling stddev bands mean each bar's upBuf/dnBuf depends ONLY on its own
// price window — completely independent of rates_total position.
// fullPass: compute all bars. Incremental: bars 1 and 0 only.
// Both are safe — no recursive seed dependency.
int tmaStart = fullPass ? rates_total - 1 : 1;
for(int i = tmaStart; i >= 0; i--)
{
CalculateTMA(i, rates_total,
TMA1_HalfLength, TMA1_Price, TMA1_BandsDeviations, TMA1_RePaint,
TMABuf1, sUpBuf1, sDnBuf1,
open, high, low, close);
CalculateTMA(i, rates_total,
TMA2_HalfLength, TMA2_Price, TMA2_BandsDeviations, TMA2_RePaint,
TMABuf2, sUpBuf2, sDnBuf2,
open, high, low, close);
}

//--- Signal loop — closed bars only, never bar 0 (still open).
// fullPass : evaluate all bars from oldest to newest.
// newBar : evaluate bar 1 only (just closed on this tick).
// other : sigStart=0 < sigEnd=1, loop never executes.
int sigStart = fullPass ? rates_total - 1 : (newBar ? 1 : 0);
int sigEnd = 1;

for(int i = sigStart; i >= sigEnd; i--)
{
//--- POB
PobPrices[i] = getPrice(Pob_Price, open, close, high, low, i, rates_total);
for(int dim = 0; dim <= 10; dim++)
MpAvg[i][dim] = MidPoint(dim, i, Pob_Period, PobPrices, MpAvg, rates_total);

int pStart = i + 1;
int pCount = MathMin(PobLevel, rates_total - i - 1);
double hiPrice = PobPrices[i], loPrice = PobPrices[i];
if(pCount > 0)
{
int maxIdx = ArrayMaximum(PobPrices, pStart, pCount);
int minIdx = ArrayMinimum(PobPrices, pStart, pCount);
if(maxIdx >= 0) hiPrice = PobPrices[maxIdx];
if(minIdx >= 0) loPrice = PobPrices[minIdx];
}
double avg = 0;
for(int k = 0; k <= PobLevel; k++) avg += MpAvg[i][k];
avg /= (PobLevel + 1);
double pobValue = (hiPrice != loPrice)
? 100.0 * (PobPrices[i] - avg) / (hiPrice - loPrice)
: 0;
int pobTrend = (pobValue > 0) ? 1 : (pobValue < 0) ? -1 : 0;

//--- smTMMS trend
double histValue = 0;
switch(Histogram_Line)
{
case Stochastic_2: histValue = sStoch2[i]; break;
case Stochastic_1: histValue = sStoch1[i]; break;
case RSI: histValue = RSIBuf[i]; break;
}
int smtmmTrend = (histValue > 0 && RSIBuf[i] > 0 && sStoch1[i] > 0) ? 1 :
(histValue < 0 && RSIBuf[i] < 0 && sStoch1[i] < 0) ? -1 : 0;

int ultimateTrend = (smtmmTrend == 1 && pobTrend == 1) ? 1 :
(smtmmTrend == -1 && pobTrend == -1) ? -1 : 0;

//--- TMA band conditions.
// i+1 = trigger bar (broke the band).
// i = confirmation bar (reversal candle). Both fully closed.
if(i + 1 >= rates_total) continue;

bool tma1Buy = (high[i+1] > sUpBuf1[i+1] && close[i+1] > open[i+1] && close[i] < open[i]);
bool tma1Sell = (low[i+1] < sDnBuf1[i+1] && close[i+1] < open[i+1] && close[i] > open[i]);
bool tma2Buy = (high[i+1] > sUpBuf2[i+1] && close[i+1] > open[i+1] && close[i] < open[i]);
bool tma2Sell = (low[i+1] < sDnBuf2[i+1] && close[i+1] < open[i+1] && close[i] > open[i]);

bool buySignal = (ultimateTrend == 1 && tma1Buy && tma2Buy);
bool sellSignal = (ultimateTrend == -1 && tma1Sell && tma2Sell);

//--- Arrow placement.
// Names unique per symbol+TF — no cross-TF contamination.
// ObjectCreate returns false if name exists — existing arrows untouched.
// buySignal -> sell arrow (red, arrowcode 234) above high
// sellSignal -> buy arrow (lime, arrowcode 233) below low
if(buySignal)
{
string name = cName + tfStr + "Sell_" + IntegerToString((long)time[i]);
if(ObjectCreate(0, name, OBJ_ARROW, 0, time[i],
high[i] + ArrowOffsetPoints * _Point))
{
ObjectSetInteger(0, name, OBJPROP_ARROWCODE, 234);
ObjectSetInteger(0, name, OBJPROP_COLOR, clrRed);
ObjectSetInteger(0, name, OBJPROP_WIDTH, 3);
ObjectSetInteger(0, name, OBJPROP_BACK, false);

//--- Alert: fires on bar 1 only (live confirmation candle).
// Guard on lastAlertTime prevents duplicate alerts within same bar.
if(i == 1 && time[i] != lastAlertTime)
{
lastAlertTime = time[i];
string msg = "TradeEntry2 SELL SIGNAL | " + _Symbol +
" " + TFToString(PERIOD_CURRENT) +
" | Bar: " + TimeToString(time[i], TIME_DATE|TIME_MINUTES);
if(Alert_Popup) Alert(msg);
if(Alert_Sound) PlaySound("alert.wav");
if(Alert_Push) SendNotification(msg);
if(Alert_Email) SendMail("TradeEntry2 SELL — " + _Symbol, msg);
}
}
}
if(sellSignal)
{
string name = cName + tfStr + "Buy_" + IntegerToString((long)time[i]);
if(ObjectCreate(0, name, OBJ_ARROW, 0, time[i],
low[i] - ArrowOffsetPoints * _Point))
{
ObjectSetInteger(0, name, OBJPROP_ARROWCODE, 233);
ObjectSetInteger(0, name, OBJPROP_COLOR, clrLime);
ObjectSetInteger(0, name, OBJPROP_WIDTH, 3);
ObjectSetInteger(0, name, OBJPROP_BACK, false);

//--- Alert: fires on bar 1 only (live confirmation candle).
// Guard on lastAlertTime prevents duplicate alerts within same bar.
if(i == 1 && time[i] != lastAlertTime)
{
lastAlertTime = time[i];
string msg = "TradeEntry2 BUY SIGNAL | " + _Symbol +
" " + TFToString(PERIOD_CURRENT) +
" | Bar: " + TimeToString(time[i], TIME_DATE|TIME_MINUTES);
if(Alert_Popup) Alert(msg);
if(Alert_Sound) PlaySound("alert.wav");
if(Alert_Push) SendNotification(msg);
if(Alert_Email) SendMail("TradeEntry2 BUY — " + _Symbol, msg);
}
}
}
}

ChartRedraw(0);
return(rates_total);
}

//+------------------------------------------------------------------+
double getPrice(ENUM_APPLIED_PRICE tprice, const double &open[],
const double &close[], const double &high[],
const double &low[], int i, int bars)
{
if(i < 0 || i >= bars) return(0);
switch(tprice)
{
case PRICE_CLOSE: return(close[i]);
case PRICE_OPEN: return(open[i]);
case PRICE_HIGH: return(high[i]);
case PRICE_LOW: return(low[i]);
case PRICE_MEDIAN: return((high[i] + low[i]) / 2.0);
case PRICE_TYPICAL: return((high[i] + low[i] + close[i]) / 3.0);
case PRICE_WEIGHTED: return((high[i] + low[i] + close[i] + close[i]) / 4.0);
}
return(0);
}

//+------------------------------------------------------------------+
//| CalculateTMA v2.04 |
//| |
//| Band computation: direct rolling standard deviation. |
//| upBuf[i] = TMA[i] + bandsDev * stddev(price-TMA, window) |
//| dnBuf[i] = TMA[i] - bandsDev * stddev(price-TMA, window) |
//| |
//| Each bar's band depends ONLY on its own price history — never |
//| on rates_total position. Closed bar bands are stable forever. |
//| No drift, no repainting, no delayed arrows. |
//+------------------------------------------------------------------+
void CalculateTMA(int i, int rates_total, int halfLength,
ENUM_APPLIED_PRICE aprice, double bandsDev, bool rePaint,
double &tmBuf[], double &upBuf[], double &dnBuf[],
const double &open[], const double &high[],
const double &low[], const double &close[])
{
//--- Step 1: triangular moving average (unchanged from original)
int actual_hl = MathMin(halfLength, rates_total - i - 1);
double sum = (actual_hl + 1.0) * getPrice(aprice, open, close, high, low, i, rates_total);
double sumw = actual_hl + 1.0;

for(int j = 1, k = actual_hl; j <= actual_hl; j++, k--)
{
sum += k * getPrice(aprice, open, close, high, low, i + j, rates_total);
sumw += k;
if(rePaint && j <= i)
{
sum += k * getPrice(aprice, open, close, high, low, i - j, rates_total);
sumw += k;
}
}
tmBuf[i] = (sumw != 0)
? sum / sumw
: getPrice(aprice, open, close, high, low, i, rates_total);

//--- Step 2: rolling standard deviation over 2*halfLength+1 bar window.
// Window uses bars i..i+winLen-1 (older bars only, no future data).
// Every term uses fixed price[] and tmBuf[] — zero dependency on
// rates_total, so this value never changes once the bar is closed.
int winLen = 2 * halfLength + 1;
int winEnd = i; // newest bar in window (bar i itself)
int winStart = MathMin(i + winLen - 1, rates_total - 1); // oldest bar in window
int winCount = winStart - winEnd + 1;

double sumSq = 0.0;
for(int w = winEnd; w <= winStart; w++)
{
double p = getPrice(aprice, open, close, high, low, w, rates_total);
double diff = p - tmBuf[w];
sumSq += diff * diff;
}

double stddev = (winCount > 0) ? MathSqrt(sumSq / winCount) : 0.0;
upBuf[i] = tmBuf[i] + bandsDev * stddev;
dnBuf[i] = tmBuf[i] - bandsDev * stddev;
}

//+------------------------------------------------------------------+
double MidPoint(int forDim, int shift, int period, const double &prices[],
double &mpavg[][], int rates_total)
{
double maxVal = (forDim == 0) ? prices[shift] : mpavg[shift][forDim - 1];
double minVal = maxVal;
for(int ii = 1; ii < period && (shift + ii) < rates_total; ii++)
{
double val = (forDim == 0) ? prices[shift + ii] : mpavg[shift + ii][forDim - 1];
if(val < minVal) minVal = val;
if(val > maxVal) maxVal = val;
}
return((maxVal + minVal) / 2.0);
}

//+------------------------------------------------------------------+
//| Delete TE2_ arrows for this symbol+timeframe only |
//+------------------------------------------------------------------+
void DeleteTE2Objects()
{
string prefix = cName + tfStr;
int total = ObjectsTotal(0, 0, -1);
for(int i = total - 1; i >= 0; i--)
{
string objName = ObjectName(0, i, 0, -1);
if(StringFind(objName, prefix) == 0)
{
if(!ObjectDelete(0, objName))
Print("TE2: failed to delete: ", objName, " error: ", GetLastError());
}
}
}
//+------------------------------------------------------------------+

BTW, any Universal EA will handle this strategy, because the arrows are buffered, so there already exist a number of Universal EAs which can trade based on buffers.

The SL is wrong!
I mean, it's point-based, which means that in reality an EA will often be unable to execute the trade because of the confusion, like in the image:

So, the logical thing to do, if the SL will have any sense, is to place the SL either at the H/L of the signal bar, or the next higher high or lower low? Or provide an option in inputs.

PS, I also just noticed that it still doesn't update in real time.
When you recompile it, it shows new arrows that weren't there before.

I didn't touch that. It was originally like this