TD_Points&Line_mgtd1.1

Download script
Author: Vladislav Goshkov (VG)
TD_Points&Line_mgtd1.1

This script is designed to analyze price action by identifying key structural trends and potential reversal points on a trading chart. Instead of using standard indicators like moving averages, it focuses on the geometry of price movements to identify "Supply" and "Demand" zones and calculate potential price targets.

Core Logic Overview

1. Trend Identification (Supply and Demand) The script scans historical price data to find significant high points (peaks) and low points (troughs).

  • Supply Points: It looks for specific price peaks where the high was greater than the surrounding bars, establishing a "ceiling" or a point of resistance.
  • Demand Points: Conversely, it identifies deep troughs where the low was lower than the surrounding bars, establishing a "floor" or a point of support.

2. Trendline Construction Once these key peaks and troughs are identified, the script connects them to form dynamic trendlines:

  • An Upward Trendline is drawn connecting sequential high points.
  • A Downward Trendline is drawn connecting sequential low points. These lines visually represent the current trajectory of the market's momentum.

3. Breakout Detection and Target Calculation The primary intelligence of the script lies in detecting when the price "breaks" through these established trendlines. When a breakout occurs, the script performs the following:

  • Intersection Analysis: It calculates the exact mathematical point where the current price closes across the trendline.
  • Target Projection: Based on the angle and distance of the trendline break, it calculates three different potential price targets (PP1, PP2, and PP3). These are derived from the historical volatility and "gap" distances of previous price movements.
  • Signal Visualization: When a breakout is confirmed based on specific conditions (such as price gaps or opening positions), the script places an arrow on the chart to signal the event.

4. Dynamic Target Plotting The script automatically draws horizontal lines on the chart representing the calculated targets:

  • It provides multiple target levels (different styles and colors) to give the user a range of potential "destination" prices for the current price move.
  • These lines update in real-time as new data points are processed, ensuring the targets stay relevant to the most recent breakout.

Visual Elements on Chart

  • Trendlines: Solid lines showing the path of Supply and Demand.
  • Breakout Arrows: Markers indicating where the trendline was breached.
  • Horizontal Targets: Various dashed and solid lines marking the projected areas where price might move next.
  • Reference Marker: A specific point (an arrow) used to mark the current calculation basis on the chart.
8 Views
0 Downloads
0 Favorites
TD_Points&Line_mgtd1.1 
//+------------------------------------------------------------------+
//|                                        TD_Points&Lines_mgtd1.mq4 |
//|                                           Vladislav Goshkov (VG) |
//|                                                      4vg@mail.ru |
//+------------------------------------------------------------------+
#property copyright "Vladislav Goshkov (VG)"
#property link      "4vg@mail.ru"
//----
#property indicator_chart_window
//----
extern int StepBack=0;
extern bool Qw1=True;
extern bool Qw2=True;
extern bool Qw3=True;
extern color UpLineColor=Blue;
extern int   UpLnWidth=1;
extern color DnLineColor=Red;
extern int   DnLnWidth=1;
extern color MarkColor  =Blue;
extern int   MarkNumber =217;
//----
int i=1,NP=0,D=0,
    iB_Up=0,iB_Dn=0,
    S1=0,
    S2=0,
    UpLev=0,
    DownLev=0,
    iP_Up=0,
    iP_Dn=0,
    value=0,
    CurPeriod=0,
    shift=0;
//----
datetime  nTime=0;
//----
double UpV=0,
       DownV=0,
       iP=0,
       target=0,
       UpP[2]={0,0},
       DownP[2]={0,0},
       PP1=0,PP2=0,PP3=0;
int    DownBT[2]={0,0}, // Bar Time
       UpBT[2]={0,0},
       UpB[2]={0,0},    // Bar Num
       DownB[2]={0,0};
string buff_str="";
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
  {
//---- indicators
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| Custor indicator deinitialization function                       |
//+------------------------------------------------------------------+
int deinit()
  {
//---- TODO: add your code here
   Comment(" ");
   ObjectsDeleteAll();
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int start()
  {
   int Target_Style[4]={STYLE_DASH,STYLE_DASH,STYLE_DASH,STYLE_SOLID},
   Target_Color[4]={DimGray,MediumSpringGreen,SeaGreen,Blue},
   Target_LW[4]   ={ 1, 1, 1, 2 };
   double target[4];
//---- TODO: add your code here
     if((nTime!=Time[0]) || (CurPeriod!=Period()))
   {
      UpP[0]=0;
      UpP[1]=0;
//=================================================
//******** Ïîèñê îïîðíûõ òî÷åê ïðåäëîæåíèÿ ********
//=================================================
        for(i=2+StepBack,D=2,NP=0; (NP<D)&&(i<Bars); i++) 
        { //Begin
           if (High[i]!= High[i+1]) 
           {
            if((High[i]>High[i+1] && High[i]>High[i-1] && High[i]>Close[i+2])
                    && High[i]> UpP[0])
                    {
               UpB[NP] =i;
               UpBT[NP]=Time[i];
               UpP[NP] =High[i];
               NP++;
              }
           }
           if (High[i]== High[i+1])  
           {
              if((High[i]>High[i+2] && High[i]>High[i-1] && High[i]>Close[i+3])&& High[i]> UpP[0])
              {
               UpB[NP] =i;
               UpBT[NP]=Time[i];
               UpP[NP] =High[i];
               NP++;
              }
           }
           if(i==(Bars-2))
           {
            UpB[NP] =i;
            UpBT[NP]=Time[i];
            UpP[NP] =High[i];
            break;
           }
        }//for(i=2+StepBack,D=2,NP=0; NP<D; ) {//End;
//=================================================
//********** Ïîèñê îïîðíûõ òî÷åê ñïðîñà ***********
//=================================================
      DownP[0]=1000000000;
      DownP[1]=1000000000;
        for(i=2+StepBack,D=2,NP=0; (NP<D)&&(i<Bars); i++) 
        {//Begin
           if (Low[i]!= Low[i+1])  
           {
              if((Low[i]<Low[i+1] && Low[i]<Low[i-1] && Low[i]<Close[i+2])&& Low[i]< DownP[0] )
              {
               DownB[NP]=i;
               DownBT[NP]= Time[i];
               DownP[NP]=Low[i];
               NP++;
              }
            //i++;
           }
           if (Low[i]== Low[i+1])  
           {
              if((Low[i]<Low[i+2] && Low[i]<Low[i-1] && Low[i]<Close[i+3])&& Low[i]< DownP[0] )
              {
               DownB[NP]=i;
               DownBT[NP]= Time[i];
               DownP[NP]=Low[i];
               NP++;
              }
            //i++;
           }
           if (i==(Bars-2))
           {
            DownB[NP]=i;
            DownBT[NP]= Time[i];
            DownP[NP]=Low[i];
            break;
           }
        }//End;
      UpV=(UpP[1]-UpP[0])/(UpB[0]-UpB[1]);
      DownV=(DownP[1]-DownP[0])/(DownB[0]-DownB[1]);
//=================================================
//****       Ðèñóåì  TD-ëèíèè                  ****
//=================================================
      buff_str="TD_Up";
        if(ObjectFind(buff_str)==-1) 
        {
         ObjectCreate(buff_str, OBJ_TREND, 0, UpBT[1], UpP[1],UpBT[0], UpP[0]);
         ObjectSet(buff_str, OBJPROP_STYLE, STYLE_SOLID);
         ObjectSet(buff_str, OBJPROP_COLOR, UpLineColor);
         ObjectSet(buff_str, OBJPROP_WIDTH, UpLnWidth);
        }
        else 
        {
         ObjectMove(buff_str, 1, UpBT[0], UpP[0]);
         ObjectMove(buff_str, 2, UpBT[1], UpP[1]);
        }
      buff_str="TD_Dn";
        if(ObjectFind(buff_str)==-1) 
        {
         ObjectCreate(buff_str, OBJ_TREND, 0, DownBT[1], DownP[1],DownBT[0], DownP[0]);
         ObjectSet(buff_str, OBJPROP_STYLE, STYLE_SOLID);
         ObjectSet(buff_str, OBJPROP_COLOR, DnLineColor);
         ObjectSet(buff_str, OBJPROP_WIDTH, DnLnWidth);
        }
        else 
        {
         ObjectMove(buff_str, 1, DownBT[0], DownP[0]);
         ObjectMove(buff_str, 2, DownBT[1], DownP[1]);
        }
      CurPeriod=Period();
      nTime=Time[0];
     }//if (nTime <> Time[0]) {
//----
   for(i=0;i<4;i++) target[i]=0;
     for( i=UpB[0]; i>=StepBack; i--)
     {
        if((Close[i]>UpP[0]+UpV*(UpB[0]-i)) && (Close[i+1]<=UpP[0]+UpV*(UpB[0]-(i+1))))
        {
         iB_Up=i;
         iP=UpP[0]+UpV*(UpB[0]-i);
         iP_Up=iP;
         S1=Lowest(NULL,0,MODE_LOW,UpB[1]-i,i);
         S2=Lowest(NULL,0,MODE_CLOSE,UpB[1]-i,i);
//----
         PP1=iP+((UpP[1]+UpV*(UpB[1]-S1))-Low[S1]);
         PP2=iP+((UpP[1]+UpV*(UpB[1]-S2))-Low[S2]);
         PP3=iP+((UpP[1]+UpV*(UpB[1]-S1))-Close[S1]);
         if((Qw1 && Close[i+2]>Close[i+1])
         || (Qw2 && Open[i]> iP)
             || (Qw3 && (Close[i+1]+(Close[i+1]-MathMin(Low[i+1],Close[i+2])))<iP)){
            target[0]=PP1;
            target[1]=PP2;
            target[2]=PP3;
            target[3]=(PP1+PP2+PP3)/3;
            buff_str="Break_Sig_Up";
              if(ObjectFind(buff_str)==-1) 
              {
               ObjectCreate(buff_str, OBJ_ARROW,0, Time[iB_Up], iP+2*Point );
               ObjectSet(buff_str, OBJPROP_ARROWCODE, 164);
               ObjectSet(buff_str, OBJPROP_COLOR, Red);
              }
              else 
              {
               ObjectMove(buff_str, 0, Time[iB_Up], iP+2*Point );
              }
           }
        }
     }
     for( i=DownB[0]; i>=StepBack;i--) 
     {
        if((Close[i]<DownP[0]+DownV*(DownB[0]-i)) && (Close[i+1]>=DownP[0]+DownV*(DownB[0]-(i+1))))
        {
         iB_Dn=i;
         iP=DownP[0]+DownV*(DownB[0]-i);
         iP_Dn=iP;
         S1=Highest(NULL,0,MODE_HIGH,DownB[1]-i,i);
         S2=Highest(NULL,0,MODE_CLOSE,DownB[1]-i,i);
//----
         PP1=iP-(High[S1]-(DownP[1]+DownV*(DownB[1]-S1)));
         PP2=iP-(High[S2]-(DownP[1]+DownV*(DownB[1]-S2)));
         PP3=iP-(Close[S1]-(DownP[1]+DownV*(DownB[1]-S1)));
         if((Qw1 && Close[i+2]<Close[i+1] )
        || (Qw2 && Open[i] < iP )
            || (Qw3 && (Close[i+1]+(Close[i+1]-MathMax(High[i+1],Close[i+2])))>iP))
            {
            target[0]=PP1;
            target[1]=PP2;
            target[2]=PP3;
            target[3]=(PP1+PP2+PP3)/3;
            buff_str="Break_Sig_Dn";
              if(ObjectFind(buff_str)==-1) 
              {
               ObjectCreate(buff_str, OBJ_ARROW,0, Time[iB_Dn], iP+2*Point );
               ObjectSet(buff_str, OBJPROP_ARROWCODE, 164);
               ObjectSet(buff_str, OBJPROP_COLOR, Blue);
              }
              else 
              {
               ObjectMove(buff_str, 0, Time[iB_Dn], iP+2*Point );
              }
           }
        }
     }//for( i=DownB[1]; i>=StepBack;i--) {
     for(i=3;i>=0;i--) 
     {
      buff_str="Target"+i;
        if(ObjectFind(buff_str)==-1) 
        {
         ObjectCreate(buff_str, OBJ_HLINE,0, Time[0], target[i] );
         ObjectSet(buff_str, OBJPROP_STYLE, Target_Style[i]);
         ObjectSet(buff_str, OBJPROP_COLOR, Target_Color[i]);
         ObjectSet(buff_str, OBJPROP_WIDTH, Target_LW[i]);
        }
        else 
        {
         ObjectMove(buff_str, 0, Time[0], target[i] );
        }
     }
//----
   string buff_str="TD_LatestCulcBar";
     if(ObjectFind(buff_str)==-1) {
      ObjectCreate(buff_str, OBJ_ARROW,0, Time[StepBack], Low[StepBack]-2*Point );
      ObjectSet(buff_str, OBJPROP_ARROWCODE, MarkNumber);
      ObjectSet(buff_str, OBJPROP_COLOR, MarkColor);
     }
     else 
     {
      ObjectMove(buff_str, 0, Time[StepBack], Low[StepBack]-2*Point );
     }
   return(0);
  }
//+------------------------------------------------------------------+

Similar scripts

Murrey_Math_Line_X_eng_v1

This indicator projects a multi-layered support and resistance framework by partitioning price action into an eight-part octave based on fractal range analysis.

MMLevls_VG_v1

TD_Points_Line_mgtd1

This indicator identifies significant price supply and demand zones based on historical extremes and calculates linear trajectory slopes to project breakout targets and signal entry points.

TD_Points & Line

This indicator identifies historical price extrema to project supply and demand trendlines, plotting dynamic target levels based on volume-weighted structural deviations.

TD_Points&Line_mgtd1

This indicator identifies structural supply and demand zones by calculating linear price gradients between historical extrema to project dynamic break-out targets.

TD_Points&Line_Auto

This indicator identifies structural supply and demand zones by calculating linear regression trajectories between pivot highs and lows to project potential reversal targets.

TDpoints&lines

This indicator identifies structural pivot highs and lows to project dynamic trend targets based on momentum velocity and historical price extremes.

PivotsMultiTimes

This indicator calculates and projects dynamic floor and ceiling price levels by synthesizing high/low/close data from specific historical timeframes.

Critical_PointsV2_v1

This indicator projects a symmetrical grid of Fibonacci-based price levels relative to a user-selectable moving average to identify potential reversal zones.

_252300Float2

Linear Regression

Comments