DinapoliTargets_001

Download script
Author: mishanya
DinapoliTargets_001

This script is designed to analyze historical price movements on a trading chart to identify key structural trends and automatically project specific mathematical price targets. By interpreting market behavior, it helps traders visualize where price might head next based on recent momentum and structural shifts.

Core Logic and Behavior

1. Market Structure Recognition The script begins by scanning historical data to identify significant "swings" in price. It looks for peaks and valleys (highs and lows) to determine the direction of the market. Rather than just looking at every minor tick, it filters out noise to find major turning points, much like a ZigZag indicator. It tracks these points to build a chronological history of the market's structural "skeleton."

2. Trend Analysis and Alerts As the script identifies these swings, it monitors whether the price is moving upward or downward. If it detects a significant shift in the trend—specifically when price moves significantly higher or lower than previous recorded points—it can trigger a real-time audio alert. This allows traders to be notified of major structural changes immediately without having to watch the screen constantly.

3. Mathematical Price Projections The heart of the script lies in its calculation of potential "targets." Once it identifies the most recent significant moves (referred to as Points A, B, and C), it applies specific mathematical ratios to calculate where the price might travel next. These calculations include:

  • Fibonacci-style Ratios: It uses specific multipliers (such as 0.618, 1.618, and others) to project standard extension levels.
  • Dynamic Targets: Depending on whether the current move is bullish or bearish, it calculates several different levels:
    • Target 1 & Target 3: Based on mathematical extensions.
    • Target 2: A projection of the total distance moved in the previous leg.
    • Fantasy/Crazy Dream Levels: Extreme projections for very strong trends.

4. Visual Mapping For users who enable the "targets" feature, the script draws physical lines directly on the trading chart. These lines provide a visual roadmap for:

  • Start and Stop Points: Defining the entry/exit boundaries of the current move.
  • Target Lines: Marking the specific price levels where the script expects the market to react or pause based on its calculations.

Summary for the Trader

In simple terms, this tool "reads" the history of your chart to find out how far the market has moved and in what direction. It then takes that data and draws a series of dotted lines on your screen, showing you exactly where the next mathematical "resting points" are likely to be, helping you plan your profit-taking and stop-loss levels based on structural geometry.

Miscellaneous
Implements a curve of type %1
17 Views
0 Downloads
0 Favorites
DinapoliTargets_001 
//+------------------------------------------------------------------+
//|                                              DinapoliTargets.mq4 |
//|                                            mishanya_fx@yahoo.com |
//|                                                                  |
//+------------------------------------------------------------------+
#property copyright "mishanya"
#property link      "mishanya_fx@yahoo.com"

#property indicator_chart_window
#property indicator_buffers 1
#property indicator_color1 AliceBlue
#property indicator_width1 4
//---- input parameters
extern int       barn=300;
extern int       Length=6;
double prev;
double last;
double alertBar;
extern int SoundAlertMode = 1;
extern bool targets = false;
//---- buffers
double ExtMapBuffer1[];
//double ExtMapBuffer2[];
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
  {
//---- indicators
   SetIndexEmptyValue(0,0.0);
 SetIndexDrawBegin(0, barn);
   SetIndexStyle(0,DRAW_SECTION);
   SetIndexBuffer(0,ExtMapBuffer1);
   IndicatorShortName("DIN");
   
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| Custor indicator deinitialization function                       |
//+------------------------------------------------------------------+
int deinit()
  {

   ObjectDelete("Start line");
   ObjectDelete("Stop line");
   ObjectDelete("Target1 line");
   ObjectDelete("Target2 line");
   ObjectDelete("Target3 line");
   ObjectDelete("info0");
   ObjectDelete("info1");
   ObjectDelete("info2");
   ObjectDelete("info3");
   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int start()
  {
   int    counted_bars=IndicatorCounted();
   int shift,Swing,Swing_n,uzl,i,zu,zd,mv;
   double PointA,PointB,PointC,Target1,Target2,Target3,Fantnsy,CrazyDream,Start,Stop;
   double LL,HH,BH,BL,NH,NL; 
   double Uzel[10000][3]; 
   string text;
// loop from first bar to current bar (with shift=0) 
      Swing_n=0;Swing=0;uzl=0; 
      BH =High[barn];BL=Low[barn];zu=barn;zd=barn; 

for (shift=barn;shift>=0;shift--) { 
      LL=10000000;HH=-100000000; 
   for (i=shift+Length;i>=shift+1;i--) { 
         if (Low[i]< LL) {LL=Low[i];} 
         if (High[i]>HH) {HH=High[i];} 
   } 


   if (Low[shift]<LL && High[shift]>HH){ 
      Swing=2; 
      if (Swing_n==1) {zu=shift+1;} 
      if (Swing_n==-1) {zd=shift+1;} 
   } else { 
      if (Low[shift]<LL) {Swing=-1;} 
      if (High[shift]>HH) {Swing=1;} 
   } 

   if (Swing!=Swing_n && Swing_n!=0) { 
   if (Swing==2) {
      Swing=-Swing_n;BH = High[shift];BL = Low[shift]; 
   } 
      uzl=uzl+1; 
   if (Swing==1) {
      Uzel[uzl][1]=zd;
      Uzel[uzl][2]=BL;
   } 
   if (Swing==-1) {
      Uzel[uzl][1]=zu;
      Uzel[uzl][2]=BH; 
   } 
      BH = High[shift];
      BL = Low[shift]; 
   } 

   if (Swing==1) { 
      if (High[shift]>=BH) {BH=High[shift];zu=shift;}} 
      if (Swing==-1) {
          if (Low[shift]<=BL) {BL=Low[shift]; zd=shift;}} 
      Swing_n=Swing; 
   } 
   for (i=1;i<=uzl;i++) { 
      //text=DoubleToStr(Uzel[i][1],0);
      //text=;
         mv=StrToInteger(DoubleToStr(Uzel[i][1],0));

       if(prev > Uzel[i][2] && ExtMapBuffer1[mv]!=Uzel[i][2] && SoundAlertMode > 0 && Bars>alertBar) {Alert("Dinap Targets ZigZag going Down on ",Symbol()," Period ",Period());alertBar = Bars;}
      if(prev < Uzel[i][2] && ExtMapBuffer1[mv]!=Uzel[i][2] && SoundAlertMode > 0 && Bars>alertBar) {Alert("Dinap Targets ZigZag going Up on ",Symbol()," Period ",Period());alertBar = Bars;}
      ExtMapBuffer1[mv]=Uzel[i][2];
      prev = Uzel[i][2];

   } 

PointA = Uzel[uzl-2][2];
PointB = Uzel[uzl-1][2];
PointC = Uzel[uzl][2];

Target1=NormalizeDouble((PointB-PointA)*0.618+PointC,4);
Target2=PointB-PointA+PointC;
Target3=NormalizeDouble((PointB-PointA)*1.618+PointC,4);
Fantnsy=NormalizeDouble((PointB-PointA)*2.618+PointC,4);
CrazyDream=NormalizeDouble((PointB-PointA)*4.618+PointC,4);
if (PointB<PointC)
{
Start= NormalizeDouble((PointB-PointA)*0.318+PointC,4)-(Ask-Bid);
Stop=PointC+2*(Ask-Bid);
}
if (PointB>PointC)
{
Start= NormalizeDouble((PointB-PointA)*0.318+PointC,4)+(Ask-Bid);
Stop=PointC-2*(Ask-Bid);
}


   if (ObjectFind("Start Line") != 0 && targets == true) 
     {
      ObjectCreate("Start line",OBJ_HLINE,0,Time[0],Start);
      ObjectSet("Start line",OBJPROP_COLOR,Bisque);
      ObjectSet("Start line",OBJPROP_WIDTH,3);
      ObjectSet("Start line",OBJPROP_STYLE,STYLE_DOT);
     }
     else
     {
     ObjectMove("Start line", 0,Time[0],Start);
     }

   if (ObjectFind("Stop Line") != 0 && targets == true) 
     {
      ObjectCreate("Stop line",OBJ_HLINE,0,Time[0],Stop);
      ObjectSet("Stop line",OBJPROP_COLOR,Red);
      ObjectSet("Stop line",OBJPROP_WIDTH,3);
      ObjectSet("Stop line",OBJPROP_STYLE,STYLE_DOT);
     }
     else
     {
     ObjectMove("Stop line", 0,Time[0],Stop);
     }
    
    if (ObjectFind("Target1 Line") != 0 && targets == true) 
     {
      ObjectCreate("Target1 line",OBJ_HLINE,0,Time[0],Target1);
      ObjectSet("Target1 line",OBJPROP_COLOR,Yellow);
      ObjectSet("Target1 line",OBJPROP_WIDTH,3);
      ObjectSet("Target1 line",OBJPROP_STYLE,STYLE_DOT);
     }
     else
     {
     ObjectMove("Target1 line", 0,Time[0],Target1);
     }

    if (ObjectFind("Target2 Line") != 0 && targets == true) 
     {
      ObjectCreate("Target2 line",OBJ_HLINE,0,Time[0],Target2);
      ObjectSet("Target2 line",OBJPROP_COLOR,PaleTurquoise);
      ObjectSet("Target2 line",OBJPROP_WIDTH,3);
      ObjectSet("Target2 line",OBJPROP_STYLE,STYLE_DOT);
     }
     else
     {
     ObjectMove("Target2 line", 0,Time[0],Target2);
     }
    
    if (ObjectFind("Target3 Line") != 0 && targets == true) 
     {
      ObjectCreate("Target3 line",OBJ_HLINE,0,Time[0],Target3);
      ObjectSet("Target3 line",OBJPROP_COLOR,LightSkyBlue);
      ObjectSet("Target3 line",OBJPROP_WIDTH,3);
      ObjectSet("Target3 line",OBJPROP_STYLE,STYLE_DOT);
     }
     else
     {
     ObjectMove("Target3 line", 0,Time[0],Target3);
     }
   return(0);
  }
//+------------------------------------------------------------------+

Similar scripts

DinapoliTargets

This indicator identifies structural swing points to project automated Fibonacci extension levels and dynamic entry/exit zones based on price volatility.

DinapoliTarget_Malay

This indicator identifies structural pivot points to project automated Fibonacci retracement levels and dynamic price targets based on market volatility.

DinapoliTarget_Malay_v1

This indicator identifies structural swing points to project dynamic entry levels and multiple profit targets based on 0.618, 1.618, and 2.618 Fibonacci extensions.

k3-ZZ

This indicator identifies structural swing points to project dynamic Fibonacci expansion levels and automated risk-reward price targets.

DinapoliTargets-Kuskus

This indicator identifies structural swing points and projects dynamic Fibonacci extension levels and automated trade targets based on price volatility.

camarilladt1

This indicator dynamically plots Camarilla Breakout levels, standard Pivot Points, and Midpoint levels based on historical daily high, low, and close price data.

DinapoliTargets_v1

This indicator identifies structural price swings to project dynamic entry, stop-loss, and multi-level profit targets based on Fibonacci expansion ratios.

camarilladt1_v1

This indicator projects daily price boundaries by synthesizing standard Pivot Points, Camarilla breakout levels, and sequential midpoint anchors onto a single visual interface.

Woodies Pivots Modified Into Fib Pivots

This script calculates and plots daily support and resistance levels by blending traditional pivot point arithmetic with Fibonacci retracement ratios of the previous day's price range.

Critical_Points_v1

This indicator projects symmetrical horizontal price levels based on various moving average types to identify potential structural pivot points and liquidity zones.

DeMark Projected High & Low Script

This script dynamically calculates and plots projected daily high and low price targets based on DeMark's weighted pivot formula derived from the previous day's open, high, low, and close prices.

Comments