NRTR Rosh v2_v2
Download scriptThis script functions as a dynamic trend-tracking indicator designed to identify market direction and significant price levels based on volatility. Instead of using simple moving averages, it relies on the relationship between current price action and the Average True Range (ATR)—a common metric used to measure how much an asset typically moves in a given period.
Core Logic Overview
The indicator operates by establishing a "Trend" state. It constantly monitors whether the market is moving in an upward or downward direction by reacting to specific price triggers. It creates two types of dynamic boundaries: Ceilings (upper limits) and Floors (lower limits), alongside Support/Resistance Buffers.
How it Works
The logic follows a continuous cycle of observation and reaction:
1. Trend Identification
- The script determines the initial trend based on whether the price closed higher or lower than it opened at a specific starting point.
- If the market is in an Uptrend, the script focuses on tracking "Ceiling" levels and "Buy Support" buffers.
- If the market is in a Downtrend, it focuses on "Floor" levels and "Sell Resistance" buffers.
2. Dynamic Boundary Management
- In an Uptrend: The indicator tracks the highest points (Ceilings). If the price breaks above the current Ceiling, the script recognizes this as a new high, resets the Ceiling to the current price, and updates the Buy Support buffer.
- In a Downtrend: The indicator tracks the lowest points (Floors). If the price drops below the current Floor, the script recognizes this as a new low, resets the Floor to the current price, and updates the Sell Resistance buffer.
3. Trend Reversal Logic The script looks for "exhaustion" or "breakdown" signals to switch the trend:
- If the market is in an Uptrend but the price falls below a specific calculated buffer (a significant drop relative to volatility), the script triggers a trend reversal, switching the status to a Downtrend and resetting the logic accordingly.
- Conversely, if the market is in a Downtrend but the price pushes above a calculated buffer (a significant rally relative to volatility), the script switches the status to an Uptrend.
Visual Output
The script provides several visual cues on the chart:
- Arrows: These signify specific "Limit" points where the trend is being monitored or potential reversals are identified.
- Dynamic Buffers: These represent price levels calculated by taking the current price and adjusting it by a multiple of the ATR (volatility). This ensures that the support and resistance lines expand during high-volatility markets and contract during low-volatility markets.
Summary for the User
Essentially, this script acts as an "intelligent" boundary tracker. It doesn't just draw static lines; it evolves with the market. It identifies the current "flow" of price and automatically updates its support and resistance levels based on how much the market is actually moving (volatility), alerting you when the price breaks these dynamic boundaries or signals a potential shift in the prevailing trend.
//+------------------------------------------------------------------+
//| NRTR Rosh v2.mq4 |
//| Rosh |
//| http://forexsystems.ru/phpBB/index.php |
//+------------------------------------------------------------------+
#property copyright "Rosh"
#property link "http://forexsystems.ru/phpBB/index.php"
#property indicator_chart_window
#property indicator_buffers 4
#property indicator_color1 Tomato
#property indicator_color2 DeepSkyBlue
#property indicator_color3 DeepSkyBlue
#property indicator_color4 Tomato
//---- input parameters
extern int PerATR=40;
extern double kATR=2.0;
//---- buffers
double SellBuffer[];
double BuyBuffer[];
double Ceil[];
double Floor[];
double Trend[];
//+------------------------------------------------------------------+
//| Custom indicator initialization function |
//+------------------------------------------------------------------+
int init()
{
//---- indicators
IndicatorBuffers(5);
SetIndexStyle(0,DRAW_ARROW);
SetIndexArrow(0,251);
SetIndexBuffer(0,SellBuffer);
SetIndexEmptyValue(0,0.0);
SetIndexLabel(0,"SellLimit");
SetIndexStyle(1,DRAW_ARROW);
SetIndexArrow(1,251);
SetIndexBuffer(1,BuyBuffer);
SetIndexEmptyValue(1,0.0);
SetIndexLabel(1,"BuyLimit");
SetIndexStyle(2,DRAW_ARROW);
SetIndexArrow(2,159);
SetIndexBuffer(2,Ceil);
SetIndexEmptyValue(2,0.0);
SetIndexLabel(2,"Ceil");
SetIndexStyle(3,DRAW_ARROW);
SetIndexArrow(3,159);
SetIndexBuffer(3,Floor);
SetIndexEmptyValue(3,0.0);
SetIndexLabel(3,"Floor");
SetIndexBuffer(4,Trend);
SetIndexEmptyValue(4,0);
//----
return(0);
}
//+------------------------------------------------------------------+
//| ïðîáèòèå âåðõà ÄÀÓÍòðåíäà |
//+------------------------------------------------------------------+
bool BreakDown(int shift)
{
bool result=false;
if (Close[shift]>SellBuffer[shift+1]) result=true;
return(result);
}
//+------------------------------------------------------------------+
//| ïðîáèòèå äíà ÀÏòðåíäà |
//+------------------------------------------------------------------+
bool BreakUp(int shift)
{
bool result=false;
if (Close[shift]<BuyBuffer[shift+1]) result=true;
return(result);
}
//+------------------------------------------------------------------+
//| âçÿòèå íîâîãî ìèíèìóìà ïî ÄÀÓÍòðåíäó |
//+------------------------------------------------------------------+
bool BreakFloor(int shift)
{
bool result=false;
if (High[shift]<Floor[shift+1]) result=true;
return(result);
}
//+------------------------------------------------------------------+
//| âçÿòèå íîâîãî ìàêñèìóìà ïî ÀÏòðåíäó |
//+------------------------------------------------------------------+
bool BreakCeil(int shift)
{
bool result=false;
if (Low[shift]>Ceil[shift+1]) result=true;
return(result);
}
//+------------------------------------------------------------------+
//| îïðåäåëåíèå ïðåäûäóùåãî òðåíäà |
//+------------------------------------------------------------------+
bool Uptrend(int shift)
{
//Print("Trend=",Trend[shift+1]);
bool result=false;
if (Trend[shift+1]==1) result=true;
if (Trend[shift+1]==-1) result=false;
if ((Trend[shift+1]!=1)&&(Trend[shift+1]!=-1)) Print("Âíèìàíèå! Òðåíä íå îïðåäåëåí, òàêîãî áûòü íå ìîæåò. Áàð îò êîíöà ",(Bars-shift));
return(result);
}
//+------------------------------------------------------------------+
//| âû÷èñëåíèå âîëàòèëüíîñòè |
//+------------------------------------------------------------------+
double ATR(int iPer,int shift)
{
double result;
//result=iMA(NULL,0,Per,0,MODE_SMA,PRICE_HIGH,shift+1)-iMA(NULL,0,Per,0,MODE_SMA,PRICE_LOW,shift+1);
result=iATR(NULL,0,iPer,shift);
//if (result>1.0) Alert("Áîëüøîé ÀÒÐ=",result);
//Print("ATR[",shift,"]=",result);
return(result);
}
//+------------------------------------------------------------------+
//| óñòàíîâêà íîâîãî óðîâíÿ ïîòîëêà |
//+------------------------------------------------------------------+
void NewCeil(int shift)
{
Ceil[shift]=Close[shift];
Floor[shift]=0.0;
}
//+------------------------------------------------------------------+
//| óñòàíîâêà íîâîãî óðîâíÿ ïîëà |
//+------------------------------------------------------------------+
void NewFloor(int shift)
{
Floor[shift]=Close[shift];
Ceil[shift]=0.0;
}
//+------------------------------------------------------------------+
//| óñòàíîâêà óðîâíÿ ïîääåðæêè ÀÏòðåíäà |
//+------------------------------------------------------------------+
void SetBuyBuffer(int shift)
{
BuyBuffer[shift]=Close[shift]-kATR*ATR(PerATR,shift);
SellBuffer[shift]=0.0;
}
//+------------------------------------------------------------------+
//| óñòàíîâêà óðîâíÿ ïîääåðæêè ÄÀÓÍòðåíäà |
//+------------------------------------------------------------------+
void SetSellBuffer(int shift)
{
SellBuffer[shift]=Close[shift]+kATR*ATR(PerATR,shift);
BuyBuffer[shift]=0.0;
}
//+------------------------------------------------------------------+
//| ðåâåðñ òðåíäà è óñòàíîâêà íîâûõ óðîâíåé |
//+------------------------------------------------------------------+
void NewTrend(int shift)
{
if (Trend[shift+1]==1)
{
Trend[shift]=-1;
NewFloor(shift);
SetSellBuffer(shift);
}
else
{
Trend[shift]=1;
NewCeil(shift);
SetBuyBuffer(shift);
}
if ((Trend[shift+1]!=1)&&(Trend[shift+1]!=-1)) Print("Âíèìàíèå! Òðåíä íå îïðåäåëåí, òàêîãî áûòü íå ìîæåò");
}
//+------------------------------------------------------------------+
//| ïðîäîëæåíèå òðåíäà |
//+------------------------------------------------------------------+
void CopyLastValues(int shift)
{
SellBuffer[shift]=SellBuffer[shift+1];
BuyBuffer[shift]=BuyBuffer[shift+1];
Ceil[shift]=Ceil[shift+1];
Floor[shift]=Floor[shift+1];
Trend[shift]=Trend[shift+1];
}
//+------------------------------------------------------------------+
//| Custor indicator deinitialization function |
//+------------------------------------------------------------------+
int deinit()
{
//----
//----
return(0);
}
//+------------------------------------------------------------------+
//| Custom indicator iteration function |
//+------------------------------------------------------------------+
int start()
{
int counted_bars=IndicatorCounted();
int limit;
if (counted_bars>0) limit=Bars-counted_bars;
if (counted_bars<0) return(0);
if (counted_bars==0)
{
limit=Bars-PerATR-1;
if (Close[limit+1]>Open[limit+1]) {Trend[limit+1]=1;Ceil[limit+1]=Close[limit+1];BuyBuffer[limit+1]=Close[limit+1]-kATR*ATR(PerATR,limit+1);}
if (Close[limit+1]<Open[limit+1]) {Trend[limit+1]=-1;Floor[limit+1]=Close[limit+1];SellBuffer[limit+1]=Close[limit+1]+kATR*ATR(PerATR,limit+1);}
if (Close[limit+1]==Open[limit+1]) {Trend[limit+1]=1;Ceil[limit+1]=Close[limit+1];BuyBuffer[limit+1]=Close[limit+1]-kATR*ATR(PerATR,limit+1);}
}
//----
for (int cnt=limit;cnt>=0;cnt--)
{
if (Uptrend(cnt))
{
//Print("UpTrend");
if (BreakCeil(cnt))
{
NewCeil(cnt);
SetBuyBuffer(cnt);
Trend[cnt]=1;
continue;
}
if (BreakUp(cnt))
{
NewTrend(cnt);
continue;
}
CopyLastValues(cnt);
}
else
{
//Print("DownTrend");
if (BreakFloor(cnt))
{
NewFloor(cnt);
SetSellBuffer(cnt);
Trend[cnt]=-1;
continue;
}
if (BreakDown(cnt))
{
NewTrend(cnt);
continue;
}
CopyLastValues(cnt);
}
}
//----
return(0);
}
//+------------------------------------------------------------------+
Comments