StepChoppy_v1.2

Download script
Author: Copyright � 2006, Forex-TSD.com
StepChoppy_v1.2

This script is designed as a visual trading tool for MetaTrader that helps traders identify the "quality" and direction of current market trends. Instead of just telling you if the price is going up or down, it categorizes the behavior of the market into four distinct stages for both bullish (upward) and bearish (downward) movements.

How it Works

The logic relies on comparing three different technical layers simultaneously:

  1. Trend Identification: It checks for a primary upward or downward trend using specific moving averages.
  2. Momentum Velocity: It uses a "Fast" measurement to see how quickly the price is currently moving.
  3. Relative Strength: It compares various strength indicators (RSI-based) to see if the current price action is stronger than the recent average or if it is losing steam.

What the Visuals Mean

The tool displays a histogram in a separate window, using different colors to represent the "health" of the trend:

For Upward Trends (Bullish):

  • Strong UpTrend: The market is moving up with high momentum and strength.
  • Retrace UpTrend: The market is still generally upward but is experiencing a temporary pullback or "breather."
  • Choppy UpTrend: The upward movement is becoming unstable or disorganized; the trend is weakening.
  • Be Ready to Change UpTrend: A warning signal that the bullish momentum is fading and a reversal or significant slowdown may be imminent.

For Downward Trends (Bearish):

  • Strong DownTrend: The market is falling with high velocity and consistent strength.
  • Retrace DownTrend: The market is primarily falling but is currently seeing a temporary minor bounce.
  • Choppy DownTrend: The downward move is becoming inconsistent or "noisy."
  • Be Ready to Change DownTrend: A warning signal that the bearish momentum is exhausted and price may soon stabilize or turn around.

Summary for the User

Essentially, this script acts as a "mood ring" for the market. It filters out the noise of random price fluctuations to show you not just where the price is going, but how strongly it is moving in that direction. This allows a trader to stay with a strong trend while potentially preparing to exit a position when the logic signals that the trend is becoming "choppy" or "ready to change."

Miscellaneous
Implements a curve of type %1
16 Views
0 Downloads
0 Favorites
StepChoppy_v1.2 
//+------------------------------------------------------------------+
//|                                                StepChoppy_v1.mq4 |
//|                                  Copyright © 2006, Forex-TSD.com |
//|                         Written by IgorAD,igorad2003@yahoo.co.uk |   
//|            http://finance.groups.yahoo.com/group/TrendLaboratory |                                      
//+------------------------------------------------------------------+
#property copyright "Copyright © 2006, Forex-TSD.com "
#property link      "http://www.forex-tsd.com/"

#property indicator_separate_window
#property indicator_minimum -0.05
#property indicator_maximum 1.05
#property indicator_buffers 8

//---- input parameters
int Length=10;
double StepSizeFast=5;
double StepSizeSlow=15;
int MAPeriod=1;
int Price=0;
int Mode=2;
//---- buffers
double UpBuffer1[];
double UpBuffer2[];
double UpBuffer3[];
double UpBuffer4[];

double DnBuffer1[];
double DnBuffer2[];
double DnBuffer3[];
double DnBuffer4[];

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
  {
   
//---- 
   SetIndexStyle(0,DRAW_HISTOGRAM,0,3,MediumBlue);
   SetIndexStyle(1,DRAW_HISTOGRAM,0,3,DodgerBlue);
   SetIndexStyle(2,DRAW_HISTOGRAM,0,3,LightBlue);
   SetIndexStyle(3,DRAW_HISTOGRAM,0,3,Aqua);
   
   SetIndexStyle(4,DRAW_HISTOGRAM,0,3,Crimson);
   SetIndexStyle(5,DRAW_HISTOGRAM,0,3,Tomato);
   SetIndexStyle(6,DRAW_HISTOGRAM,0,3,Orange);
   SetIndexStyle(7,DRAW_HISTOGRAM,0,3,Yellow);
   
   SetIndexBuffer(0,UpBuffer1);
   SetIndexBuffer(1,UpBuffer2);
   SetIndexBuffer(2,UpBuffer3);
   SetIndexBuffer(3,UpBuffer4);
   
   SetIndexBuffer(4,DnBuffer1);
   SetIndexBuffer(5,DnBuffer2);
   SetIndexBuffer(6,DnBuffer3);
   SetIndexBuffer(7,DnBuffer4);
   
//---- 
   string short_name="StepChoppy";
   IndicatorShortName(short_name);
   SetIndexLabel(0,"Strong UpTrend");
   SetIndexLabel(1,"Retrace UpTrend");   
   SetIndexLabel(2,"Choppy UpTrend");
   SetIndexLabel(3,"Be ready to change UpTrend");
   
   SetIndexLabel(4,"Strong DownTrend");
   SetIndexLabel(5,"Retrace DownTrend");   
   SetIndexLabel(6,"Choppy DownTrend");
   SetIndexLabel(7,"Be ready to change DownTrend"); 
//----
   
   SetIndexDrawBegin(0,Length);
   SetIndexDrawBegin(1,Length);
   SetIndexDrawBegin(2,Length);
   SetIndexDrawBegin(3,Length);
   SetIndexDrawBegin(4,Length);
   SetIndexDrawBegin(5,Length);
   SetIndexDrawBegin(6,Length);
   SetIndexDrawBegin(7,Length);
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| StepChoppy_v1                                                       |
//+------------------------------------------------------------------+
int start()
  {
   int  i,counted_bars=IndicatorCounted();
   double RSI, FastRSI, SlowRSI, StepMA, UpTrendMA, DnTrendMA; 
//----
   if(Bars<=Length) return(0);
//---- initial zero
   if(counted_bars<1)
      for(i=1;i<=Length;i++) 
      {
      UpBuffer1[Bars-i]=0.0;
      UpBuffer2[Bars-i]=0.0;
      UpBuffer3[Bars-i]=0.0;
      UpBuffer4[Bars-i]=0.0;
      
      DnBuffer1[Bars-i]=0.0;
      DnBuffer2[Bars-i]=0.0;
      DnBuffer3[Bars-i]=0.0;
      DnBuffer4[Bars-i]=0.0;
      }
//----
   if ( counted_bars > 0 )  int limit=Bars-counted_bars;
   if ( counted_bars ==0 )  limit=Bars-Length-1; 
        
   for(i=limit;i>=0;i--) 
   {	 
   
   UpTrendMA = iCustom(NULL,0,"StepMA_v7",Length,1.0,0,0,0,0,true,2,0,1,i);
   DnTrendMA = iCustom(NULL,0,"StepMA_v7",Length,1.0,0,0,0,0,true,2,0,2,i);       
   
   RSI=iCustom(NULL,0,"StepRSI_v5.2",Length,StepSizeFast,MAPeriod,Price,Mode,0,i);
   FastRSI=iCustom(NULL,0,"StepRSI_v5.2",Length,StepSizeFast,MAPeriod,Price,Mode,1,i);
   SlowRSI=iCustom(NULL,0,"StepRSI_v5.2",Length,StepSizeSlow,MAPeriod,Price,Mode,1,i);   
   
   UpBuffer1[i] =UpBuffer1[i+1];
   UpBuffer2[i] =UpBuffer2[i+1];
   UpBuffer3[i] =UpBuffer3[i+1];
   UpBuffer4[i] =UpBuffer4[i+1];
   
   DnBuffer1[i] =DnBuffer1[i+1];
   DnBuffer2[i] =DnBuffer2[i+1];
   DnBuffer3[i] =DnBuffer3[i+1];
   DnBuffer4[i] =DnBuffer4[i+1];
   
   if (FastRSI > SlowRSI && RSI > FastRSI && UpTrendMA!=EMPTY_VALUE) 
   {UpBuffer1[i] = 1.0;UpBuffer2[i] = 0.0;UpBuffer3[i] = 0.0;UpBuffer4[i] = 0.0;
    DnBuffer1[i] = 0.0;DnBuffer2[i] = 0.0;DnBuffer3[i] = 0.0;DnBuffer4[i] = 0.0;}
   
   else if (FastRSI > SlowRSI && RSI < FastRSI && UpTrendMA!=EMPTY_VALUE) 
   {UpBuffer1[i] = 0.0;UpBuffer2[i] = 1.0;UpBuffer3[i] = 0.0;UpBuffer4[i] = 0.0;
    DnBuffer1[i] = 0.0;DnBuffer2[i] = 0.0;DnBuffer3[i] = 0.0;DnBuffer4[i] = 0.0;}
   
   else if (FastRSI < SlowRSI && RSI > FastRSI && UpTrendMA!=EMPTY_VALUE)  
   {UpBuffer1[i] = 0.0;UpBuffer2[i] = 0.0;UpBuffer3[i] = 1.0;UpBuffer4[i] = 0.0;
    DnBuffer1[i] = 0.0;DnBuffer2[i] = 0.0;DnBuffer3[i] = 0.0;DnBuffer4[i] = 0.0;}
    
   else if (FastRSI < SlowRSI && RSI < FastRSI && UpTrendMA!=EMPTY_VALUE) 
   {UpBuffer1[i] = 0.0;UpBuffer2[i] = 0.0;UpBuffer3[i] = 0.0;UpBuffer4[i] = 1.0;
    DnBuffer1[i] = 0.0;DnBuffer2[i] = 0.0;DnBuffer3[i] = 0.0;DnBuffer4[i] = 0.0;}
   
    
   else if (FastRSI < SlowRSI && RSI < FastRSI && DnTrendMA!=EMPTY_VALUE) 
   {UpBuffer1[i] = 0.0;UpBuffer2[i] = 0.0;UpBuffer3[i] = 0.0;UpBuffer4[i] = 0.0;
    DnBuffer1[i] = 1.0;DnBuffer2[i] = 0.0;DnBuffer3[i] = 0.0;DnBuffer4[i] = 0.0;}
   
   else if (FastRSI < SlowRSI && RSI > FastRSI && DnTrendMA!=EMPTY_VALUE)    
   {UpBuffer1[i] = 0.0;UpBuffer2[i] = 0.0;UpBuffer3[i] = 0.0;UpBuffer4[i] = 0.0;
    DnBuffer1[i] = 0.0;DnBuffer2[i] = 1.0;DnBuffer3[i] = 0.0;DnBuffer4[i] = 0.0;}
   
   else if (FastRSI > SlowRSI && RSI < FastRSI && DnTrendMA!=EMPTY_VALUE)    
   {UpBuffer1[i] = 0.0;UpBuffer2[i] = 0.0;UpBuffer3[i] = 0.0;UpBuffer4[i] = 0.0;
    DnBuffer1[i] = 0.0;DnBuffer2[i] = 0.0;DnBuffer3[i] = 1.0;DnBuffer4[i] = 0.0;}
      
   else if (FastRSI > SlowRSI && RSI > FastRSI && DnTrendMA!=EMPTY_VALUE) 
   {UpBuffer1[i] = 0.0;UpBuffer2[i] = 0.0;UpBuffer3[i] = 0.0;UpBuffer4[i] = 0.0;
    DnBuffer1[i] = 0.0;DnBuffer2[i] = 0.0;DnBuffer3[i] = 0.0;DnBuffer4[i] = 1.0;}
   }

//----
   return(0);
  }
//+------------------------------------------------------------------+

Dependencies

StepMA_v7

This indicator calculates a quantized price trajectory by determining dynamic step sizes based on average range volatility and applying trend-dependent price boundaries.

StepRSI_v5.2

This indicator applies a staircase-style quantization to relative strength values, identifying significant structural shifts in price velocity while filtering out minor volatility noise.

Similar scripts

StepChoppy_v1_v1

This indicator categorizes market dynamics into four distinct states of bullish and bearish momentum by synthesizing RSI velocity crossovers with multi-layered moving average trend filters.

StepChoppy_v1

This indicator quantifies bullish and bearish market regimes by synchronizing dual-speed RSI relative positions with trend-weighted moving averages to identify structural shifts.

StepChoppy_v2_v1

This indicator synchronizes a step-based moving average with stratified RSI oscillators to categorize market dynamics into four distinct phases of trend strength, retracement, volatility, and exhaustion.

StepChoppyBars_v1

This indicator categorizes market phases by cross-referencing StepMA trend boundaries with dual-speed RSI momentum signatures to identify strong trends, retracements, and choppy equilibrium.

StepChoppy_v2

This indicator synthesizes StepMA trend direction with dual-speed StepRSI oscillators to categorize market behavior into four distinct phases of bullish and bearish momentum, including strong trends, retracements, choppy zones, and potential reversals.

StepChoppyBars_v1.1

This indicator categorizes market behavior into four distinct phases by correlating dual-speed RSI oscillators with StepMA trend filters to identify high-velocity momentum, retracements, and volatility consolidation.

StepChoppyBars_v2

This indicator categorizes price action into distinct states—including strong trends, retracements, and choppy zones—by synthesizing StepMA trend direction with multi-speed RSI momentum crossovers.

SRCx2MA

This indicator calculates the volatility variance between dual Source Moving Average (SRCma) inputs and applies an SMA smoothing filter to identify directional momentum shifts via histogram displacement.

!!channel_breakout_atr

This indicator identifies channel breakouts based on price crossing high/low of defined periods and plots potential pyramiding entry points using ATR multiples for stop loss and position sizing, adjusted for spread.

CMA

The algorithm utilizes a modified Kaufman Adaptive Moving Average logic by scaling price movement influence based on the ratio between current volatility and absolute deviation.

SRCx2MA_arr

This indicator identifies trend reversals by calculating the smoothed differential between two Source Moving Average (SRCma) values and detecting zero-line crossovers of their residual momentum.

Comments