/// <summary> /// Take a swing on the course, with the specified angle and velocity. /// Exceptions: /// AngleInvalidException /// </summary> /// <param name="angle">angle of the launch</param> /// <param name="velocity">speed of the ball</param> public void Swing(double angle, double velocity) { // Create the swing object, with the angle and velocity provided Swing swing = new Swing(angle, velocity, this); // Add the swing to the list Swings.Add(swing); // Increment the Swing Counter this.SwingCounter++; // If the distance to the hole is less than the tolerance, // the player has won, so end the course. if (this.DistanceFromHole // distance <= Course.Tolerance /* tolerance */) { this.HasEnded = true; this.HasWon = true; // If the distance is greater than the total distance plus the rough, // the player is out of bounds, so end the course in failure } else if (this.DistanceFromHole > (CourseLength + CourseRough)) { this.IsOutOfBounds = true; this.HasEnded = true; this.HasLost = true; } }
public void Swing(double angle, double velocity) { // Skapa svingen med hjälp av vinkeln och styrkan Swing swing = new Swing(angle, velocity, this); // Lägger till svingen till listan Swings.Add(swing); // Ökar slagräknaren this.SwingCounter++; // Ifall vi är inom tolleransen av vad som är att bollen är i hålet if (this.DistanceFromHole <= Course.Tolerance) { this.HasEnded = true; this.HasWon = true; // Ifall bollen har flugit utanför gränsen } else if (this.DistanceFromHole > (CourseLength + CourseRough)) { this.IsOutOfBounds = true; this.HasEnded = true; this.HasLost = true; } }
public void DisplayEndingStausToUser() { foreach (var swing in Swings) { Console.WriteLine("Swing {0}", Swings.IndexOf(swing) + 1); Console.WriteLine("Distance travelled: {0:0.00}", swing.Distance); Console.WriteLine("Angle: {0}", swing.Angle); Console.WriteLine("Velocity: {0}", swing.Velocity); } }
public void PitchOS() { Swings p = OppSwing(); int n = random.Next(100); if (p == Swings.Take) { if (n < 80) { Strike(); } else { Ball(); } } else if (p == Swings.Fastball) { if (n < 75) { Strike(); } else { int hit = random.Next(25); Hit(hit); } } else if (p == Swings.BreakingBall) { if (n < 75) { Strike(); } else { int hit = random.Next(25); Hit(hit); } } else if (p == Swings.OffSpeed) { if (n < 35) { Strike(); } else { int hit = random.Next(25); Hit(hit); } } }
public void SimulateSwing() { double distance = 0; double angleInRadians = (Math.PI / 180) * Angle; distance = Convert.ToDouble(Math.Pow(Velocity, 2) / _gravity * Math.Sin(2 * angleInRadians)); Swing swing = new Swing(Angle, Velocity, distance); Swings.Add(swing); TotalDistanceTravelled = TotalDistanceTravelled + distance; StopCondition = DistanceToCup - TotalDistanceTravelled; NoOfSwings++; SendSwingInfoToUser(distance); }
public void Swing(double angle, double velocity) { Swing swing = new Swing(angle, velocity, this); Swings.Add(swing); this.SwingCounter++; if (this.DistanceFromHole <= Ball.Tolerance) { this.Ended = true; this.Won = true; } else if (this.DistanceFromHole > Rough) { this.IsOutOfBounds = true; this.Ended = true; this.Lost = true; } }
private void CalcUpSwing(int bar, double high, bool updateHigh) { if (!updateHigh) { lastHigh = curHigh; lastHighBar = curHighBar; lastHighDuration = curHighDuration; lastHighRelation = curHighRelation; swingCounterUp++; swingSlope = 1; trendChangeBar = bar; TrendChangeBarStats upStats = new TrendChangeBarStats(CurrentBar, Open[0], High[0], Low[0], Close[0], Trend.Up); upHistory.Add(upHisIndex, upStats); bothHistory.Add(upHisIndex + dnHisIndex, upStats); upHisIndex++; } else { swingHighs.RemoveAt(swingHighs.Count - 1); } curHighBar = bar; curHigh = Math.Round(high, decimalPlaces, MidpointRounding.AwayFromZero); curHighLength = Convert.ToInt32(Math.Round((curHigh - curLow) / TickSize, 0, MidpointRounding.AwayFromZero)); curHighDuration = curHighBar - curLowBar; double dtbOffset = ATR(14)[CurrentBar - curHighBar] * dtbStrength / 100; if (curHigh > lastHigh - dtbOffset && curHigh < lastHigh + dtbOffset) { curHighRelation = Relation.Double; BackColor = Color.Yellow; doubleBottomBar = CurrentBar; TrendChangeBarStats dtStats = new TrendChangeBarStats(CurrentBar, Open[0], High[0], Low[0], Close[0], Trend.Up); dT.Add(dtIndex, dtStats); //Print(Environment.NewLine + String.Format("{0} [{1}] {2}", Time[0].ToShortDateString(), Bars.BarsSinceSession, bothHistory[bothHistory.Count - 2].ToString())); //Print(String.Format("{0} [{1}] {2} DOUBLETOP ALERT", Time[0].ToShortDateString(), Bars.BarsSinceSession, bothHistory[bothHistory.Count - 1].ToString())); dtIndex++; enableDTOrderEntry = true; } else if (curHigh < lastHigh) { curHighRelation = Relation.Lower; } else { curHighRelation = Relation.Higher; } string swingLabel = null; switch (curHighRelation) { case Relation.Higher: swingLabel = "HH"; break; case Relation.Lower: swingLabel = "LH"; break; case Relation.Double: swingLabel = "DT"; break; } if (lastHigh != 0.0 || lastLow != 0.0) { DrawLine("ZigZagUp" + swingCounterUp, true, CurrentBar - curLowBar, curLow, CurrentBar - curHighBar, curHigh, zigZagColourUp, zigZagStyle, zigZagWidth); string txtOutput = string.Format("{0}: {1} b.{2}", swingLabel, curHighLength.ToString(), curHighDuration.ToString()); DrawText("UpLabel" + swingCounterUp, true, txtOutput, CurrentBar - curHighBar, curHigh, offsetText, Color.Black, textFont, StringAlignment.Center, Color.Transparent, Color.Transparent, 0); } Swings up = new Swings(curHighBar, curHigh, curHighLength, curHighDuration, curHighRelation); swingHighs.Add(up); upCount = swingHighs.Count - 1; }
private void CalcDnSwing(int bar, double low, bool updateLow) { if (!updateLow) { lastLow = curLow; lastLowBar = curLowBar; lastLowDuration = curLowDuration; lastLowLength = curLowLength; lastLowRelation = curLowRelation; swingCounterDn++; swingSlope = -1; trendChangeBar = bar; TrendChangeBarStats dnStats = new TrendChangeBarStats(CurrentBar, Open[0], High[0], Low[0], Close[0], Trend.Down); dnHistory.Add(dnHisIndex, dnStats); bothHistory.Add(dnHisIndex + upHisIndex, dnStats); //Print(String.Format("{0} [{1}] {2}",Time[0].ToShortDateString(),Bars.BarsSinceSession,bothHistory[bothHistory.Count - 1].ToString())); dnHisIndex++; //BackColor = Color.Coral; } else { swingLows.RemoveAt(swingLows.Count - 1); } curLowBar = bar; curLow = Math.Round(low, decimalPlaces, MidpointRounding.AwayFromZero); curLowLength = Convert.ToInt32(Math.Round((curLow - curHigh) / TickSize, 0, MidpointRounding.AwayFromZero)); curLowDuration = curLowBar - curHighBar; double dtbOffset = ATR(14)[CurrentBar - curLowBar] * dtbStrength / 100; if (curLow > lastLow - dtbOffset && curLow < lastLow + dtbOffset) { curLowRelation = Relation.Double; } else if (curLow < lastLow) { curLowRelation = Relation.Lower; } else { curLowRelation = Relation.Higher; } string swingLabel = null; switch (curLowRelation) { case Relation.Higher: swingLabel = "HL"; break; case Relation.Lower: swingLabel = "LL"; break; case Relation.Double: swingLabel = "DB"; break; } if (lastHigh != 0.0 || lastLow != 0.0) { DrawLine("ZigZagDown" + swingCounterDn, true, CurrentBar - curHighBar, curHigh, CurrentBar - curLowBar, curLow, zigZagColourDn, zigZagStyle, zigZagWidth); string txtOutput = string.Format("{0}: {1} b.{2}", swingLabel, curLowLength.ToString(), curLowDuration.ToString()); DrawText("DnLabel" + swingCounterDn, true, txtOutput, CurrentBar - curLowBar, curLow, -offsetText, Color.Black, textFont, StringAlignment.Center, Color.Transparent, Color.Transparent, 0); } // On new low adjust the breakeven stop to higher low. if (swingStopLoss != null) { //Print (String.Format(" Current StopPrice {0} lastHigh {1}",swingStopLoss.StopPrice,lastHigh)); if (swingStopLoss.StopPrice > lastHigh && scalpProfitTarget == null) { // Print(Bars.BarsSinceSession+"MOVING THE STOPLOSS"); try { if (Close[0] < lastHigh) { swingStopLoss = ExitShortStop(0, true, swingStopLoss.Quantity, lastHigh, "SW.HL", "SW.DTEN"); } else if (Close[0] >= lastHigh) { ExitShortStop(0, true, swingStopLoss.Quantity, High[0] + 1 * TickSize, "SW.HL" + " MKT", "SW.DTEN"); } } catch (Exception ex) { Print("Exception caused by moving swing stop loss position" + Environment.NewLine + ex.ToString()); } } } // Print(String.Format("[{0}] {1}", Bars.BarsSinceSession, lastHigh)); Swings dn = new Swings(curLowBar, curLow, curLowLength, curLowDuration, curLowRelation); swingLows.Add(dn); downCount = swingLows.Count - 1; }
//##################################################################### private void CalcDnSwing(int bar, double low, bool updateLow) { #region New and update Swing values if (!updateLow) { if (VisualizationTypes.GannStyle == visualizationType) { for (int i = CurrentBar - trendChangeBar; i >= 0; i--) GannSwing.Set(i, curHigh); GannSwing.Set(low); } lastLow = curLow; lastLowBar = curLowBar; lastLowDateTime = curLowDateTime; lastLowDuration = curLowDuration; lastLowLength = curLowLength; lastLowPercent = curLowPercent; lastLowRelation = curLowRelation; lastLowTime = curLowTime; lastLowVolume = curLowVolume; swingCounterDn++; swingSlope = -1; trendChangeBar = bar; if (showNakedSwings == true) { nakedSwingHighsList.Add(curHigh, curHighBar); DrawRay("NakedSwingHigh" + curHigh.ToString(), false, CurrentBar - curHighBar, curHigh, CurrentBar - curHighBar - 1, curHigh, nakedSwingHighColor, nakedSwingDashStyle, nakedSwingLineWidth); } } else { if (VisualizationTypes.Dots == visualizationType || VisualizationTypes.DotsAndLines == visualizationType) { DoubleBottom.Reset(CurrentBar - curLowBar); LowerLow.Reset(CurrentBar - curLowBar); HigherLow.Reset(CurrentBar - curLowBar); } swingLows.RemoveAt(swingLows.Count - 1); } curLowBar = bar; curLow = Math.Round(low, decimalPlaces, MidpointRounding.AwayFromZero); curLowTime = ToTime(Time[CurrentBar - curLowBar]); curLowDateTime = Time[CurrentBar - curLowBar]; curLowLength = Convert.ToInt32(Math.Round((curLow - curHigh) / TickSize, 0, MidpointRounding.AwayFromZero)); if (curHighLength != 0) curLowPercent = Math.Round(100.0 / curHighLength * Math.Abs(curLowLength), 1); curLowDuration = curLowBar - curHighBar; double dtbOffset = ATR(14)[CurrentBar - curLowBar] * dtbStrength / 100; if (curLow > lastLow - dtbOffset && curLow < lastLow + dtbOffset) curLowRelation = Relation.Double; else if (curLow < lastLow) curLowRelation = Relation.Lower; else curLowRelation = Relation.Higher; if (!CalculateOnBarClose) signalBarVolumeUp = Volume[0]; double swingVolume = 0.0; for (int i = CurrentBar - curLowBar; i < CurrentBar - curLowBar + curLowDuration; i++) swingVolume = swingVolume + Volume[i]; if (!CalculateOnBarClose) swingVolume = swingVolume + (Volume[CurrentBar - curHighBar] - signalBarVolumeDn); if (SwingVolumeTypes.Relativ == swingVolumeType) swingVolume = Math.Round(swingVolume / curLowDuration, 0, MidpointRounding.AwayFromZero); curLowVolume = Convert.ToInt64(swingVolume); #endregion #region Visualize swing switch (visualizationType) { case VisualizationTypes.Dots: switch (curLowRelation) { case Relation.Higher: HigherLow.Set(CurrentBar - curLowBar, curLow); break; case Relation.Lower: LowerLow.Set(CurrentBar - curLowBar, curLow); break; case Relation.Double: DoubleBottom.Set(CurrentBar - curLowBar, curLow); break; } break; case VisualizationTypes.ZigZagLines: DrawLine("ZigZagDown" + swingCounterDn, AutoScale, CurrentBar - curHighBar, curHigh, CurrentBar - curLowBar, curLow, zigZagColourDn, zigZagStyle, zigZagWidth); break; case VisualizationTypes.DotsAndLines: switch (curLowRelation) { case Relation.Higher: HigherLow.Set(CurrentBar - curLowBar, curLow); break; case Relation.Lower: LowerLow.Set(CurrentBar - curLowBar, curLow); break; case Relation.Double: DoubleBottom.Set(CurrentBar - curLowBar, curLow); break; } DrawLine("ZigZagDown" + swingCounterDn, AutoScale, CurrentBar - curHighBar, curHigh, CurrentBar - curLowBar, curLow, zigZagColourDn, zigZagStyle, zigZagWidth); break; case VisualizationTypes.GannStyle: for (int i = CurrentBar - trendChangeBar; i >= 0; i--) GannSwing.Set(i, curLow); break; } if (showNakedSwings == true && nakedSwingLowsList.Count > 0) { while (nakedSwingLowsList.Count > 0 && nakedSwingLowsList.Keys[nakedSwingLowsList.Count - 1] >= curLow) { int counter = nakedSwingLowsList.Count - 1; double nakedSwingLowPrice = nakedSwingLowsList.Keys[counter]; RemoveDrawObject("NakedSwingLow" + nakedSwingLowPrice.ToString()); if (showHistoricalNakedSwings == true) { DrawLine("NakedSwingLow" + nakedSwingCounter++, false, CurrentBar - nakedSwingLowsList.Values[counter], nakedSwingLowPrice, CurrentBar - curLowBar, nakedSwingLowPrice, nakedSwingLowColor, nakedSwingDashStyle, nakedSwingLineWidth); } nakedSwingLowsList.RemoveAt(counter); } } #endregion #region Swing value output string output = null; string swingLabel = null; Color textColor = Color.Transparent; if (SwingLengthTypes.False != swingLengthType) { switch (swingLengthType) { case SwingLengthTypes.Ticks: output = curLowLength.ToString(); break; case SwingLengthTypes.Ticks_And_Price: output = curLowLength.ToString() + " / " + curLow.ToString(); break; case SwingLengthTypes.Points: output = (curLowLength * TickSize).ToString(); break; case SwingLengthTypes.Price: output = curLow.ToString(); break; case SwingLengthTypes.Price_And_Points: output = curLow.ToString() + " / " + (curLowLength * TickSize).ToString(); break; case SwingLengthTypes.Price_And_Ticks: output = curLow.ToString() + " / " + curLowLength.ToString(); break; case SwingLengthTypes.Percent: output = (Math.Round((100.0 / curHigh * (curLowLength * TickSize)), 2, MidpointRounding.AwayFromZero)).ToString(); break; } } if (showSwingDuration != SwingDurationTypes.False) { string outputDuration = ""; TimeSpan timeSpan; int hours, minutes, seconds = 0; switch (showSwingDuration) { case SwingDurationTypes.Bars: outputDuration = curLowDuration.ToString(); break; case SwingDurationTypes.HoursMinutes: timeSpan = curLowDateTime.Subtract(curHighDateTime); hours = timeSpan.Hours; minutes = timeSpan.Minutes; if (hours == 0) outputDuration = "0:" + minutes.ToString(); else if (minutes == 0) outputDuration = hours + ":00"; else outputDuration = hours + ":" + minutes; break; case SwingDurationTypes.MinutesSeconds: timeSpan = curLowDateTime.Subtract(curHighDateTime); minutes = timeSpan.Minutes; seconds = timeSpan.Seconds; if (minutes == 0) outputDuration = "0:" + seconds.ToString(); else if (seconds == 0) outputDuration = minutes + ":00"; else outputDuration = minutes + ":" + seconds; break; case SwingDurationTypes.HoursTotal: timeSpan = curLowDateTime.Subtract(curHighDateTime); outputDuration = Math.Round(timeSpan.TotalHours, 1, MidpointRounding.AwayFromZero).ToString(); break; case SwingDurationTypes.MinutesTotal: timeSpan = curLowDateTime.Subtract(curHighDateTime); outputDuration = Math.Round(timeSpan.TotalMinutes, 1, MidpointRounding.AwayFromZero).ToString(); break; case SwingDurationTypes.SecondsTotal: timeSpan = curLowDateTime.Subtract(curHighDateTime); outputDuration = Math.Round(timeSpan.TotalSeconds, 1, MidpointRounding.AwayFromZero).ToString(); break; case SwingDurationTypes.Days: timeSpan = curLowDateTime.Subtract(curHighDateTime); outputDuration = Math.Round(timeSpan.TotalDays, 1, MidpointRounding.AwayFromZero).ToString(); break; } if (SwingLengthTypes.False != swingLengthType) output = output + " / " + outputDuration; else output = outputDuration; } switch (curLowRelation) { case Relation.Higher: swingLabel = "HL"; textColor = textColourHigher; break; case Relation.Lower: swingLabel = "LL"; textColor = textColorLower; break; case Relation.Double: swingLabel = "DB"; textColor = textColourDtb; break; } if (output != null) DrawText("DnLength" + swingCounterDn, AutoScale, output.ToString(), CurrentBar - curLowBar, curLow, -textOffsetLength, textColor, textFont, StringAlignment.Center, Color.Transparent, Color.Transparent, 0); if (showSwingLabel) DrawText("DnLabel" + swingCounterDn, AutoScale, swingLabel, CurrentBar - curLowBar, curLow, -textOffsetLabel, textColor, textFont, StringAlignment.Center, Color.Transparent, Color.Transparent, 0); if (showSwingPercent && curLowPercent != 0) { DrawText("DnPerc" + swingCounterDn, AutoScale, curLowPercent.ToString() + "%", CurrentBar - curLowBar, curLow, -textOffsetPercent, textColor, textFont, StringAlignment.Center, Color.Transparent, Color.Transparent, 0); } if (SwingTimeTypes.False != showSwingTime) { string timeOutput = ""; switch (showSwingTime) { case SwingTimeTypes.Integer: timeOutput = curLowTime.ToString(); break; case SwingTimeTypes.HourMinute: timeOutput = string.Format("{0:t}", Time[CurrentBar - curLowBar]); break; case SwingTimeTypes.HourMinuteSecond: timeOutput = string.Format("{0:T}", Time[CurrentBar - curLowBar]); break; case SwingTimeTypes.DayMonth: timeOutput = string.Format("{0:dd.MM}", Time[CurrentBar - curHighBar]); break; } DrawText("DnTime" + swingCounterDn, AutoScale, timeOutput, CurrentBar - curLowBar, curLow, -textOffsetTime, textColor, textFont, StringAlignment.Center, Color.Transparent, Color.Transparent, 0); } if (SwingVolumeTypes.False != swingVolumeType) { DrawText("DnVolume" + swingCounterDn, AutoScale, TruncIntToStr(Convert.ToInt32(swingVolume)), CurrentBar - curLowBar, curLow, -textOffsetVolume, textColor, textFont, StringAlignment.Center, Color.Transparent, Color.Transparent, 0); } #endregion Swings dn = new Swings(curLowBar, curLow, curLowLength, curLowDuration, curLowRelation); swingLows.Add(dn); dnCount = swingLows.Count - 1; }
//##################################################################### #endregion /// <summary> /// Called on each bar update event (incoming tick) /// </summary> protected override void OnBarUpdate() { #region Initialize varibles //================================================================= if (FirstTickOfBar) { stopOutsideBarCalc = false; if (CurrentBar == 1) { curHighBar = curLowBar = CurrentBar; curHigh = High[1]; curLow = Low[1]; curHighDateTime = curLowDateTime = lastHighDateTime = lastLowDateTime = Time[CurrentBar]; Swings up = new Swings(curHighBar, curHigh, 0, 0, curHighRelation); Swings dn = new Swings(curLowBar, curLow, 0, 0, curLowRelation); swingHighs.Add(up); swingLows.Add(dn); upCount = swingHighs.Count; dnCount = swingLows.Count; } } // Set new/update high/low back to false, to avoid function // calls which depends on them newHigh = newLow = updateHigh = updateLow = false; // Checks to make sure we have enough bars to calculate the indicator if (CurrentBar < swingSize) return; //================================================================= #endregion #region Swing calculation // Swing calculation ============================================== switch (swingType) { case SwingTypes.Standard: #region Standard Swing if (swingSlope == 1 && High[0] <= curHigh) newHigh = false; else newHigh = true; if (swingSlope == -1 && Low[0] >= curLow) newLow = false; else newLow = true; if (FirstTickOfBar && VisualizationTypes.GannStyle == visualizationType) { if (swingSlope == 1) GannSwing.Set(curHigh); else GannSwing.Set(curLow); } // CalculatOnBarClose == true ================================================= if (CalculateOnBarClose) { if (newHigh) { for (int i = 1; i < swingSize + 1; i++) { if (High[0] <= High[i]) { newHigh = false; break; } } } if (newLow) { for (int i = 1; i < swingSize + 1; i++) { if (Low[0] >= Low[i]) { newLow = false; break; } } } if (newHigh && newLow) { if (swingSlope == -1) newHigh = false; else newLow = false; } } // CalculatOnBarClose == false ================================================ else { if (FirstTickOfBar) newSwing = 0; if (newSwing != -1) { if (newHigh) { for (int i = 1; i < swingSize + 1; i++) { if (High[0] <= High[i]) { newHigh = false; break; } } if (newHigh) newSwing = 1; } } if (newSwing != 1) { if (newLow) { for (int i = 1; i < swingSize + 1; i++) { if (Low[0] >= Low[i]) { newLow = false; break; } } if (newLow) newSwing = -1; } } if (newSwing == 1) newLow = false; if (newSwing == -1) newHigh = false; } // Set new high or low ======================================================== if (newHigh) { if (swingSlope != 1) { bar = CurrentBar - HighestBar(High, CurrentBar - curLowBar); price = High[HighestBar(High, CurrentBar - curLowBar)]; updateHigh = false; } else { bar = CurrentBar; price = High[0]; updateHigh = true; } CalcUpSwing(bar, price, updateHigh); } else if (newLow) { if (swingSlope != -1) { bar = CurrentBar - LowestBar(Low, CurrentBar - curHighBar); price = Low[LowestBar(Low, CurrentBar - curHighBar)]; updateLow = false; } else { bar = CurrentBar; price = Low[0]; updateLow = true; } CalcDnSwing(bar, price, updateLow); } // ============================================================================ #endregion break; case SwingTypes.Gann: #region Set bar property //================================================================= if (paintBars) { if (High[0] > High[1]) { if (Low[0] < Low[1]) { barType = BarType.OutsideBar; BarColor = outsideBarColour; } else { barType = BarType.UpBar; BarColor = upBarColour; } } else { if (Low[0] < Low[1]) { barType = BarType.DnBar; BarColor = dnBarColour; } else { barType = BarType.InsideBar; BarColor = insideBarColour; } } } else { if (High[0] > High[1]) { if (Low[0] < Low[1]) barType = BarType.OutsideBar; else barType = BarType.UpBar; } else { if (Low[0] < Low[1]) barType = BarType.DnBar; else barType = BarType.InsideBar; } } //=================================================================== #endregion #region Gann Swing // Gann swing ================================================================= #region Up swing // Up Swing =================================================================== if (swingSlope == 1) { if (FirstTickOfBar && VisualizationTypes.GannStyle == visualizationType) GannSwing.Set(curHigh); switch (barType) { // Up bar ============================================================= case BarType.UpBar: consecutiveBars = 0; consecutiveBarValue = 0.0; if (High[0] > curHigh) { updateHigh = true; CalcUpSwing(CurrentBar, High[0], true); if ((consecutiveBars + 1) == swingSize) stopOutsideBarCalc = true; } break; // Down bar =========================================================== case BarType.DnBar: if (consecutiveBarNumber != CurrentBar) { if (consecutiveBarValue == 0.0) { consecutiveBars++; consecutiveBarNumber = CurrentBar; consecutiveBarValue = Low[0]; } else if (Low[0] < consecutiveBarValue) { consecutiveBars++; consecutiveBarNumber = CurrentBar; consecutiveBarValue = Low[0]; } } else if (Low[0] < consecutiveBarValue) consecutiveBarValue = Low[0]; if (consecutiveBars == swingSize || (useBreakouts && Low[0] < curLow)) { consecutiveBars = 0; consecutiveBarValue = 0.0; newLow = true; bar = CurrentBar - LowestBar(Low, CurrentBar - curHighBar); price = Low[LowestBar(Low, CurrentBar - curHighBar)]; CalcDnSwing(bar, price, false); } break; // Inside bar ========================================================= case BarType.InsideBar: if (!ignoreInsideBars) { consecutiveBars = 0; consecutiveBarValue = 0.0; } break; // Outside bar ======================================================== case BarType.OutsideBar: if (High[0] > curHigh) { updateHigh = true; CalcUpSwing(CurrentBar, High[0], true); } else if (!stopOutsideBarCalc) { if (consecutiveBarNumber != CurrentBar) { if (consecutiveBarValue == 0.0) { consecutiveBars++; consecutiveBarNumber = CurrentBar; consecutiveBarValue = Low[0]; } else if (Low[0] < consecutiveBarValue) { consecutiveBars++; consecutiveBarNumber = CurrentBar; consecutiveBarValue = Low[0]; } } else if (Low[0] < consecutiveBarValue) consecutiveBarValue = Low[0]; if (consecutiveBars == swingSize || (useBreakouts && Low[0] < curLow)) { consecutiveBars = 0; consecutiveBarValue = 0.0; newLow = true; bar = CurrentBar - LowestBar(Low, CurrentBar - curHighBar); price = Low[LowestBar(Low, CurrentBar - curHighBar)]; CalcDnSwing(bar, price, false); } } break; } } // End up swing =============================================================== #endregion #region Down swing // Down swing ================================================================= else { if (FirstTickOfBar && VisualizationTypes.GannStyle == visualizationType) GannSwing.Set(curLow); switch (barType) { // Dwon bar =========================================================== case BarType.DnBar: consecutiveBars = 0; consecutiveBarValue = 0.0; if (Low[0] < curLow) { updateLow = true; CalcDnSwing(CurrentBar, Low[0], true); if ((consecutiveBars + 1) == swingSize) stopOutsideBarCalc = true; } break; // Up bar ============================================================= case BarType.UpBar: if (consecutiveBarNumber != CurrentBar) { if (consecutiveBarValue == 0.0) { consecutiveBars++; consecutiveBarNumber = CurrentBar; consecutiveBarValue = High[0]; } else if (High[0] > consecutiveBarValue) { consecutiveBars++; consecutiveBarNumber = CurrentBar; consecutiveBarValue = High[0]; } } else if (High[0] > consecutiveBarValue) consecutiveBarValue = High[0]; if (consecutiveBars == swingSize || (useBreakouts && High[0] > curHigh)) { consecutiveBars = 0; consecutiveBarValue = 0.0; newHigh = true; bar = CurrentBar - HighestBar(High, CurrentBar - curLowBar); price = High[HighestBar(High, CurrentBar - curLowBar)]; CalcUpSwing(bar, price, false); } break; // Inside bar ========================================================= case BarType.InsideBar: if (!ignoreInsideBars) { consecutiveBars = 0; consecutiveBarValue = 0.0; } break; // Outside bar ======================================================== case BarType.OutsideBar: if (Low[0] < curLow) { updateLow = true; CalcDnSwing(CurrentBar, Low[0], true); } else if (!stopOutsideBarCalc) { if (consecutiveBarNumber != CurrentBar) { if (consecutiveBarValue == 0.0) { consecutiveBars++; consecutiveBarNumber = CurrentBar; consecutiveBarValue = High[0]; } else if (High[0] > consecutiveBarValue) { consecutiveBars++; consecutiveBarNumber = CurrentBar; consecutiveBarValue = High[0]; } } else if (High[0] > consecutiveBarValue) consecutiveBarValue = High[0]; if (consecutiveBars == swingSize || (useBreakouts && High[0] > curHigh)) { consecutiveBars = 0; consecutiveBarValue = 0.0; newHigh = true; bar = CurrentBar - HighestBar(High, CurrentBar - curLowBar); price = High[HighestBar(High, CurrentBar - curLowBar)]; CalcUpSwing(bar, price, false); } } break; } } // End down swing ============================================================= #endregion // End Gann swing ============================================================= #endregion break; } // End swing calculation ========================================== #endregion }
//##################################################################### #endregion #region CalcUpSwing(int bar, double high, bool updateHigh) //##################################################################### private void CalcUpSwing(int bar, double high, bool updateHigh) { #region New and update swing values if (!updateHigh) { if (VisualizationTypes.GannStyle == visualizationType) { for (int i = CurrentBar - trendChangeBar; i >= 0; i--) GannSwing.Set(i, curLow); GannSwing.Set(high); } lastHigh = curHigh; lastHighBar = curHighBar; lastHighDateTime = curHighDateTime; lastHighDuration = curHighDuration; lastHighLength = curHighLength; lastHighTime = curHighTime; lastHighPercent = curHighPercent; lastHighRelation = curHighRelation; lastHighVolume = curHighVolume; swingCounterUp++; swingSlope = 1; trendChangeBar = bar; upFlip.Set(true); if (showNakedSwings == true) { nakedSwingLowsList.Add(curLow, curLowBar); DrawRay("NakedSwingLow" + curLow.ToString(), false, CurrentBar - curLowBar, curLow, CurrentBar - curLowBar - 1, curLow, nakedSwingLowColor, nakedSwingDashStyle, nakedSwingLineWidth); } #if NT7 if (statisticPosition != StatisticPositions.False) dnStatistic(); #endif } else { if (VisualizationTypes.Dots == visualizationType || VisualizationTypes.DotsAndLines == visualizationType) { DoubleTop.Reset(CurrentBar - curHighBar); HigherHigh.Reset(CurrentBar - curHighBar); LowerHigh.Reset(CurrentBar - curHighBar); } swingHighs.RemoveAt(swingHighs.Count - 1); } curHighBar = bar; curHigh = Math.Round(high, decimalPlaces, MidpointRounding.AwayFromZero); curHighTime = ToTime(Time[CurrentBar - curHighBar]); curHighDateTime = Time[CurrentBar - curHighBar]; curHighLength = Convert.ToInt32(Math.Round((curHigh - curLow) / TickSize, 0, MidpointRounding.AwayFromZero)); if (curLowLength != 0) curHighPercent = Math.Round(100.0 / Math.Abs(curLowLength) * curHighLength, 1); curHighDuration = curHighBar - curLowBar; double dtbOffset = ATR(14)[CurrentBar - curHighBar] * dtbStrength / 100; if (curHigh > lastHigh - dtbOffset && curHigh < lastHigh + dtbOffset) curHighRelation = Relation.Double; else if (curHigh < lastHigh) curHighRelation = Relation.Lower; else curHighRelation = Relation.Higher; if (!CalculateOnBarClose) signalBarVolumeDn = Volume[0]; double swingVolume = 0.0; for (int i = 0; i < curHighDuration; i++) swingVolume = swingVolume + Volume[i]; if (!CalculateOnBarClose) swingVolume = swingVolume + (Volume[CurrentBar - curLowBar] - signalBarVolumeUp); if (SwingVolumeTypes.Relativ == swingVolumeType) swingVolume = Math.Round(swingVolume / curHighDuration, 0, MidpointRounding.AwayFromZero); curHighVolume = Convert.ToInt64(swingVolume); #endregion #region Visualize swing switch (visualizationType) { case VisualizationTypes.Dots: switch (curHighRelation) { case Relation.Higher: HigherHigh.Set(CurrentBar - curHighBar, curHigh); break; case Relation.Lower: LowerHigh.Set(CurrentBar - curHighBar, curHigh); break; case Relation.Double: DoubleTop.Set(CurrentBar - curHighBar, curHigh); break; } break; case VisualizationTypes.ZigZagLines: DrawLine("ZigZagUp" + swingCounterUp, AutoScale, CurrentBar - curLowBar, curLow, CurrentBar - curHighBar, curHigh, zigZagColourUp, zigZagStyle, zigZagWidth); break; case VisualizationTypes.DotsAndLines: switch (curHighRelation) { case Relation.Higher: HigherHigh.Set(CurrentBar - curHighBar, curHigh); break; case Relation.Lower: LowerHigh.Set(CurrentBar - curHighBar, curHigh); break; case Relation.Double: DoubleTop.Set(CurrentBar - curHighBar, curHigh); break; } DrawLine("ZigZagUp" + swingCounterUp, AutoScale, CurrentBar - curLowBar, curLow, CurrentBar - curHighBar, curHigh, zigZagColourUp, zigZagStyle, zigZagWidth); break; case VisualizationTypes.GannStyle: for (int i = CurrentBar - trendChangeBar; i >= 0; i--) GannSwing.Set(i, high); break; case VisualizationTypes.ZigZagLinesVolume: if (curHighVolume > curLowVolume) DrawLine("ZigZagUp" + swingCounterUp, AutoScale, CurrentBar - curLowBar, curLow, CurrentBar - curHighBar, curHigh, zigZagColourUp, zigZagStyle, zigZagWidth); else DrawLine("ZigZagUp" + swingCounterUp, AutoScale, CurrentBar - curLowBar, curLow, CurrentBar - curHighBar, curHigh, zigZagColourDn, zigZagStyle, zigZagWidth); break; } if (showNakedSwings == true && nakedSwingHighsList.Count > 0) { while (nakedSwingHighsList.Count > 0 && nakedSwingHighsList.Keys[0] <= curHigh) { double nakedSwingHighPrice = nakedSwingHighsList.Keys[0]; RemoveDrawObject("NakedSwingHigh" + nakedSwingHighPrice.ToString()); if (showHistoricalNakedSwings == true) { DrawLine("NakedSwingHigh" + nakedSwingCounter++, false, CurrentBar - nakedSwingHighsList.Values[0], nakedSwingHighPrice, CurrentBar - curHighBar, nakedSwingHighPrice, nakedSwingHighColor, nakedSwingDashStyle, nakedSwingLineWidth); } nakedSwingHighsList.RemoveAt(0); } } #endregion #region Swing value output string output = null; string swingLabel = null; Color textColor = Color.Transparent; if (SwingLengthTypes.False != swingLengthType) { switch (swingLengthType) { case SwingLengthTypes.Ticks: output = curHighLength.ToString(); break; case SwingLengthTypes.Ticks_And_Price: output = curHighLength.ToString() + " / " + curHigh.ToString(); break; case SwingLengthTypes.Points: output = (curHighLength * TickSize).ToString(); break; case SwingLengthTypes.Price: output = curHigh.ToString(); break; case SwingLengthTypes.Price_And_Points: output = curHigh.ToString() + " / " + (curHighLength * TickSize).ToString(); break; case SwingLengthTypes.Price_And_Ticks: output = curHigh.ToString() + " / " + curHighLength.ToString(); break; case SwingLengthTypes.Percent: output = (Math.Round((100.0 / curLow * (curHighLength * TickSize)), 2, MidpointRounding.AwayFromZero)).ToString(); break; } } if (showSwingDuration != SwingDurationTypes.False) { string outputDuration = ""; TimeSpan timeSpan; int hours, minutes, seconds = 0; switch (showSwingDuration) { case SwingDurationTypes.Bars: outputDuration = curHighDuration.ToString(); break; case SwingDurationTypes.HoursMinutes: timeSpan = curHighDateTime.Subtract(curLowDateTime); hours = timeSpan.Hours; minutes = timeSpan.Minutes; if (hours == 0) outputDuration = "0:" + minutes.ToString(); else if (minutes == 0) outputDuration = hours + ":00"; else outputDuration = hours + ":" + minutes; break; case SwingDurationTypes.MinutesSeconds: timeSpan = curHighDateTime.Subtract(curLowDateTime); minutes = timeSpan.Minutes; seconds = timeSpan.Seconds; if (minutes == 0) outputDuration = "0:" + seconds.ToString(); else if (seconds == 0) outputDuration = minutes + ":00"; else outputDuration = minutes + ":" + seconds; break; case SwingDurationTypes.HoursTotal: timeSpan = curHighDateTime.Subtract(curLowDateTime); outputDuration = Math.Round(timeSpan.TotalHours, 1, MidpointRounding.AwayFromZero).ToString(); break; case SwingDurationTypes.MinutesTotal: timeSpan = curHighDateTime.Subtract(curLowDateTime); outputDuration = Math.Round(timeSpan.TotalMinutes, 1, MidpointRounding.AwayFromZero).ToString(); break; case SwingDurationTypes.SecondsTotal: timeSpan = curHighDateTime.Subtract(curLowDateTime); outputDuration = Math.Round(timeSpan.TotalSeconds, 1, MidpointRounding.AwayFromZero).ToString(); break; case SwingDurationTypes.Days: timeSpan = curHighDateTime.Subtract(curLowDateTime); outputDuration = Math.Round(timeSpan.TotalDays, 1, MidpointRounding.AwayFromZero).ToString(); break; } if (SwingLengthTypes.False != swingLengthType) output = output + " / " + outputDuration; else output = outputDuration; } switch (curHighRelation) { case Relation.Higher: swingLabel = "HH"; textColor = textColourHigher; break; case Relation.Lower: swingLabel = "LH"; textColor = textColorLower; break; case Relation.Double: swingLabel = "DT"; textColor = textColourDtb; break; } if (output != null) DrawText("High" + swingCounterUp, AutoScale, output.ToString(), CurrentBar - curHighBar, curHigh, textOffsetLength, textColor, textFont, StringAlignment.Center, Color.Transparent, Color.Transparent, 0); if (showSwingLabel) DrawText("UpLabel" + swingCounterUp, AutoScale, swingLabel, CurrentBar - curHighBar, curHigh, textOffsetLabel, textColor, textFont, StringAlignment.Center, Color.Transparent, Color.Transparent, 0); if (showSwingPercent && curHighPercent != 0) { DrawText("UpPerc" + swingCounterUp, AutoScale, curHighPercent.ToString() + "%", CurrentBar - curHighBar, curHigh, textOffsetPercent, textColor, textFont, StringAlignment.Center, Color.Transparent, Color.Transparent, 0); } if (SwingTimeTypes.False != showSwingTime) { string timeOutput = ""; switch (showSwingTime) { case SwingTimeTypes.Integer: timeOutput = curHighTime.ToString(); break; case SwingTimeTypes.HourMinute: timeOutput = string.Format("{0:t}", Time[CurrentBar - curHighBar]); break; case SwingTimeTypes.HourMinuteSecond: timeOutput = string.Format("{0:T}", Time[CurrentBar - curHighBar]); break; case SwingTimeTypes.DayMonth: timeOutput = string.Format("{0:dd.MM}", Time[CurrentBar - curHighBar]); break; } DrawText("UpTime" + swingCounterUp, AutoScale, timeOutput, CurrentBar - curHighBar, curHigh, textOffsetTime, textColor, textFont, StringAlignment.Center, Color.Transparent, Color.Transparent, 0); } if (SwingVolumeTypes.False != swingVolumeType) { DrawText("UpVolume" + swingCounterUp, AutoScale, TruncIntToStr(curHighVolume), CurrentBar - curHighBar, curHigh, textOffsetVolume, textColor, textFont, StringAlignment.Center, Color.Transparent, Color.Transparent, 0); } #endregion #region GomCD // Uncomment the next lines to use Gomi's Cumulative Delta ==================== if (showGomCD != ShowGomCD.False) { lastHighGomCdAll = curHighGomCdAll; gomCdAllSwingHighValue = Convert.ToInt32(gomCdAllDeltaClose[0]); curHighGomCdAll = gomCdAllSwingHighValue - gomCdAllSwingLowValue; string gomCdOutput = ""; switch (showGomCD) { case ShowGomCD.AbsoluteCD: gomCdOutput = TruncIntToStr(gomCdAllSwingHighValue); break; case ShowGomCD.AbsoluteCD_And_SwingCD: gomCdOutput = TruncIntToStr(gomCdAllSwingHighValue) + " / " + TruncIntToStr(curHighGomCdAll); break; case ShowGomCD.SwingCD: gomCdOutput = TruncIntToStr(curHighGomCdAll); break; case ShowGomCD.SwingCD_And_AbsoluteCD: gomCdOutput = TruncIntToStr(curHighGomCdAll) + " / " + TruncIntToStr(gomCdAllSwingHighValue); break; } DrawText("UpGomCd" + swingCounterUp, AutoScale, gomCdOutput, CurrentBar - curHighBar, curHigh, textOffsetGomCd, textColor, textFont, StringAlignment.Center, Color.Transparent, Color.Transparent, 0); } // Uncomment till here ================================================================ #endregion Swings up = new Swings(curHighBar, curHigh, curHighLength, curHighDuration, curHighRelation); swingHighs.Add(up); upCount = swingHighs.Count - 1; }
//##################################################################### #endregion //##################################################################### #endif #endregion /// <summary> /// Called on each bar update event (incoming tick) /// </summary> protected override void OnBarUpdate() { #region Initialize varibles //================================================================= if (FirstTickOfBar) { stopOutsideBarCalc = false; entryLevelLine.Set(0); abcSignals.Set(0); if (divHiddenShortActive == true) divSignal.Set(-2); else if (divRegularShortActive == true) divSignal.Set(-1); else if (divHiddenLongActive == true) divSignal.Set(2); else if (divRegularLongActive == true) divSignal.Set(1); else divSignal.Set(0); if (curLow == 0.0 || curHigh == 0.0) { entryLong.Set(0); entryShort.Set(0); } else { entryLong.Set(entryLong[1]); entryShort.Set(entryShort[1]); } if (CurrentBar == 1) { curHighBar = curLowBar = CurrentBar; curHigh = High[1]; curLow = Low[1]; curHighDateTime = curLowDateTime = lastHighDateTime = lastLowDateTime = Time[CurrentBar]; Swings up = new Swings(curHighBar, curHigh, 0, 0, curHighRelation); Swings dn = new Swings(curLowBar, curLow, 0, 0, curLowRelation); swingHighs.Add(up); swingLows.Add(dn); upCount = swingHighs.Count; dnCount = swingLows.Count; #region GomCD // Uncomment the next lines to use Gomi's Cumulative Delta ==================== gomCdAllDeltaClose = gomCdAll.DeltaClose; // Uncomment till here ======================================================== #endregion #region Divergence switch (divergenceMode) { case DivergenceMode.Custom: // Add custom divergence indicator here break; case DivergenceMode.GomCD: #region GomCD // Uncomment the next lines to use Gomi's Cumulative Delta ==================== divergenceDataHigh = gomCdAll.DeltaHigh; divergenceDataLow = gomCdAll.DeltaHigh; // Uncomment till here ======================================================== #endregion break; case DivergenceMode.MACD: divergenceDataHigh = macd.Diff; divergenceDataLow = macd.Diff; break; case DivergenceMode.Stochastics: divergenceDataHigh = stochastics.K; divergenceDataLow = stochastics.K; break; default: break; } #endregion } } // Set new/update high/low back to false, to avoid function // calls which depends on them dnFlip.Set(false); upFlip.Set(false); newHigh = newLow = updateHigh = updateLow = false; // Checks to make sure we have enough bars to calculate the indicator if (CurrentBar < swingSize) return; //================================================================= #endregion #region Swing calculation // Swing calculation ============================================== switch (swingType) { case SwingTypes.Standard: #region Standard Swing if (swingSlope == 1 && High[0] <= curHigh) newHigh = false; else newHigh = true; if (swingSlope == -1 && Low[0] >= curLow) newLow = false; else newLow = true; if (FirstTickOfBar && VisualizationTypes.GannStyle == visualizationType) { if (swingSlope == 1) GannSwing.Set(curHigh); else GannSwing.Set(curLow); } // CalculatOnBarClose == true ================================================= if (CalculateOnBarClose) { if (newHigh) { for (int i = 1; i < swingSize + 1; i++) { if (High[0] <= High[i]) { newHigh = false; break; } } } if (newLow) { for (int i = 1; i < swingSize + 1; i++) { if (Low[0] >= Low[i]) { newLow = false; break; } } } if (newHigh && newLow) { if (swingSlope == -1) newHigh = false; else newLow = false; } } // CalculatOnBarClose == false ================================================ else { if (FirstTickOfBar) newSwing = 0; if (newSwing != -1) { if (newHigh) { for (int i = 1; i < swingSize + 1; i++) { if (High[0] <= High[i]) { newHigh = false; break; } } if (newHigh) newSwing = 1; } } if (newSwing != 1) { if (newLow) { for (int i = 1; i < swingSize + 1; i++) { if (Low[0] >= Low[i]) { newLow = false; break; } } if (newLow) newSwing = -1; } } if (newSwing == 1) newLow = false; if (newSwing == -1) newHigh = false; } // Set new high or low ======================================================== if (newHigh) { if (swingSlope != 1) { bar = CurrentBar - HighestBar(High, CurrentBar - curLowBar); price = High[HighestBar(High, CurrentBar - curLowBar)]; updateHigh = false; } else { bar = CurrentBar; price = High[0]; updateHigh = true; } CalcUpSwing(bar, price, updateHigh); } else if (newLow) { if (swingSlope != -1) { bar = CurrentBar - LowestBar(Low, CurrentBar - curHighBar); price = Low[LowestBar(Low, CurrentBar - curHighBar)]; updateLow = false; } else { bar = CurrentBar; price = Low[0]; updateLow = true; } CalcDnSwing(bar, price, updateLow); } // ============================================================================ #endregion break; case SwingTypes.Gann: #region Set bar property //================================================================= if (paintBars) { if (High[0] > High[1]) { if (Low[0] < Low[1]) { barType = BarType.OutsideBar; BarColor = outsideBarColour; } else { barType = BarType.UpBar; BarColor = upBarColour; } } else { if (Low[0] < Low[1]) { barType = BarType.DnBar; BarColor = dnBarColour; } else { barType = BarType.InsideBar; BarColor = insideBarColour; } } } else { if (High[0] > High[1]) { if (Low[0] < Low[1]) barType = BarType.OutsideBar; else barType = BarType.UpBar; } else { if (Low[0] < Low[1]) barType = BarType.DnBar; else barType = BarType.InsideBar; } } //=================================================================== #endregion #region Gann Swing // Gann swing ================================================================= #region Up swing // Up Swing =================================================================== if (swingSlope == 1) { if (FirstTickOfBar && VisualizationTypes.GannStyle == visualizationType) GannSwing.Set(curHigh); switch (barType) { // Up bar ============================================================= case BarType.UpBar: consecutiveBars = 0; consecutiveBarValue = 0.0; if (High[0] > curHigh) { updateHigh = true; CalcUpSwing(CurrentBar, High[0], true); if ((consecutiveBars + 1) == swingSize) stopOutsideBarCalc = true; } break; // Down bar =========================================================== case BarType.DnBar: if (consecutiveBarNumber != CurrentBar) { if (consecutiveBarValue == 0.0) { consecutiveBars++; consecutiveBarNumber = CurrentBar; consecutiveBarValue = Low[0]; } else if (Low[0] < consecutiveBarValue) { consecutiveBars++; consecutiveBarNumber = CurrentBar; consecutiveBarValue = Low[0]; } } else if (Low[0] < consecutiveBarValue) consecutiveBarValue = Low[0]; if (consecutiveBars == swingSize || (useBreakouts && Low[0] < curLow)) { consecutiveBars = 0; consecutiveBarValue = 0.0; newLow = true; bar = CurrentBar - LowestBar(Low, CurrentBar - curHighBar); price = Low[LowestBar(Low, CurrentBar - curHighBar)]; CalcDnSwing(bar, price, false); } break; // Inside bar ========================================================= case BarType.InsideBar: if (!ignoreInsideBars) { consecutiveBars = 0; consecutiveBarValue = 0.0; } break; // Outside bar ======================================================== case BarType.OutsideBar: if (High[0] > curHigh) { updateHigh = true; CalcUpSwing(CurrentBar, High[0], true); } else if (!stopOutsideBarCalc) { if (consecutiveBarNumber != CurrentBar) { if (consecutiveBarValue == 0.0) { consecutiveBars++; consecutiveBarNumber = CurrentBar; consecutiveBarValue = Low[0]; } else if (Low[0] < consecutiveBarValue) { consecutiveBars++; consecutiveBarNumber = CurrentBar; consecutiveBarValue = Low[0]; } } else if (Low[0] < consecutiveBarValue) consecutiveBarValue = Low[0]; if (consecutiveBars == swingSize || (useBreakouts && Low[0] < curLow)) { consecutiveBars = 0; consecutiveBarValue = 0.0; newLow = true; bar = CurrentBar - LowestBar(Low, CurrentBar - curHighBar); price = Low[LowestBar(Low, CurrentBar - curHighBar)]; CalcDnSwing(bar, price, false); } } break; } } // End up swing =============================================================== #endregion #region Down swing // Down swing ================================================================= else { if (FirstTickOfBar && VisualizationTypes.GannStyle == visualizationType) GannSwing.Set(curLow); switch (barType) { // Dwon bar =========================================================== case BarType.DnBar: consecutiveBars = 0; consecutiveBarValue = 0.0; if (Low[0] < curLow) { updateLow = true; CalcDnSwing(CurrentBar, Low[0], true); if ((consecutiveBars + 1) == swingSize) stopOutsideBarCalc = true; } break; // Up bar ============================================================= case BarType.UpBar: if (consecutiveBarNumber != CurrentBar) { if (consecutiveBarValue == 0.0) { consecutiveBars++; consecutiveBarNumber = CurrentBar; consecutiveBarValue = High[0]; } else if (High[0] > consecutiveBarValue) { consecutiveBars++; consecutiveBarNumber = CurrentBar; consecutiveBarValue = High[0]; } } else if (High[0] > consecutiveBarValue) consecutiveBarValue = High[0]; if (consecutiveBars == swingSize || (useBreakouts && High[0] > curHigh)) { consecutiveBars = 0; consecutiveBarValue = 0.0; newHigh = true; bar = CurrentBar - HighestBar(High, CurrentBar - curLowBar); price = High[HighestBar(High, CurrentBar - curLowBar)]; CalcUpSwing(bar, price, false); } break; // Inside bar ========================================================= case BarType.InsideBar: if (!ignoreInsideBars) { consecutiveBars = 0; consecutiveBarValue = 0.0; } break; // Outside bar ======================================================== case BarType.OutsideBar: if (Low[0] < curLow) { updateLow = true; CalcDnSwing(CurrentBar, Low[0], true); } else if (!stopOutsideBarCalc) { if (consecutiveBarNumber != CurrentBar) { if (consecutiveBarValue == 0.0) { consecutiveBars++; consecutiveBarNumber = CurrentBar; consecutiveBarValue = High[0]; } else if (High[0] > consecutiveBarValue) { consecutiveBars++; consecutiveBarNumber = CurrentBar; consecutiveBarValue = High[0]; } } else if (High[0] > consecutiveBarValue) consecutiveBarValue = High[0]; if (consecutiveBars == swingSize || (useBreakouts && High[0] > curHigh)) { consecutiveBars = 0; consecutiveBarValue = 0.0; newHigh = true; bar = CurrentBar - HighestBar(High, CurrentBar - curLowBar); price = High[HighestBar(High, CurrentBar - curLowBar)]; CalcUpSwing(bar, price, false); } } break; } } // End down swing ============================================================= #endregion // End Gann swing ============================================================= #endregion break; } // End swing calculation ========================================== #endregion #region Fibonacci tools //================================================================= if (newHigh || newLow || updateHigh || updateLow) { #region Fibonacci extensions // Fibonacci extensions =========================================================== if (addFibExt) { if (lastHigh == 0.0 || lastLow == 0.0) return; if (swingLows[swingLows.Count - 1].relation == Relation.Higher && swingSlope == -1) { int anchor1BarsAgo = CurrentBar - lastLowBar; int anchor2BarsAgo = CurrentBar - curHighBar; int anchor3BarsAgo = CurrentBar - curLowBar; double anchor1Y = lastLow; double anchor2Y = curHigh; double anchor3Y = curLow; DrawFibonacciExtensions("FibExtUp", false, anchor1BarsAgo, anchor1Y, anchor2BarsAgo, anchor2Y, anchor3BarsAgo, anchor3Y); } else if (swingLows[swingLows.Count - 1].relation == Relation.Higher && swingSlope == 1) { int anchor1BarsAgo = CurrentBar - lastLowBar; int anchor2BarsAgo = CurrentBar - lastHighBar; int anchor3BarsAgo = CurrentBar - curLowBar; double anchor1Y = lastLow; double anchor2Y = lastHigh; double anchor3Y = curLow; DrawFibonacciExtensions("FibExtUp", false, anchor1BarsAgo, anchor1Y, anchor2BarsAgo, anchor2Y, anchor3BarsAgo, anchor3Y); } else RemoveDrawObject("FibExtUp"); if (swingHighs[swingHighs.Count - 1].relation == Relation.Lower && swingSlope == 1) { int anchor1BarsAgo = CurrentBar - lastHighBar; int anchor2BarsAgo = CurrentBar - curLowBar; int anchor3BarsAgo = CurrentBar - curHighBar; double anchor1Y = lastHigh; double anchor2Y = curLow; double anchor3Y = curHigh; DrawFibonacciExtensions("FibExtDn", false, anchor1BarsAgo, anchor1Y, anchor2BarsAgo, anchor2Y, anchor3BarsAgo, anchor3Y); } else if (swingHighs[swingHighs.Count - 1].relation == Relation.Lower && swingSlope == -1) { int anchor1BarsAgo = CurrentBar - lastHighBar; int anchor2BarsAgo = CurrentBar - lastLowBar; int anchor3BarsAgo = CurrentBar - curHighBar; double anchor1Y = lastHigh; double anchor2Y = lastLow; double anchor3Y = curHigh; DrawFibonacciExtensions("FibExtDn", false, anchor1BarsAgo, anchor1Y, anchor2BarsAgo, anchor2Y, anchor3BarsAgo, anchor3Y); } else RemoveDrawObject("FibExtDn"); } // ================================================================================ #endregion #region Fibonacci retracements // Fibonacci retracements ========================================================= if (addFastFibRet) { int anchor1BarsAgo = 0; int anchor2BarsAgo = 0; double anchor1Y = 0.0; double anchor2Y = 0.0; if (swingSlope == 1) { anchor1BarsAgo = CurrentBar - curLowBar; anchor1Y = curLow; anchor2BarsAgo = CurrentBar - curHighBar; anchor2Y = curHigh; } else { anchor1BarsAgo = CurrentBar - curHighBar; anchor1Y = curHigh; anchor2BarsAgo = CurrentBar - curLowBar; anchor2Y = curLow; } DrawFibonacciRetracements("FastFibRet", AutoScale, anchor1BarsAgo, anchor1Y, anchor2BarsAgo, anchor2Y); } if (addSlowFibRet) { if (lastHigh == 0.0 || lastLow == 0.0) return; int anchor1BarsAgo = 0; int anchor2BarsAgo = 0; double anchor1Y = 0.0; double anchor2Y = 0.0; if (swingSlope == 1) { anchor1BarsAgo = CurrentBar - lastHighBar; anchor1Y = lastHigh; anchor2BarsAgo = CurrentBar - curLowBar; anchor2Y = curLow; } else { anchor1BarsAgo = CurrentBar - lastLowBar; anchor1Y = lastLow; anchor2BarsAgo = CurrentBar - curHighBar; anchor2Y = curHigh; } if ((swingSlope == 1 && curHigh < lastHigh) || (swingSlope == -1 && curLow > lastLow)) DrawFibonacciRetracements("SlowFibRet", AutoScale, anchor1BarsAgo, anchor1Y, anchor2BarsAgo, anchor2Y); else RemoveDrawObject("SlowFibRet"); } #endregion } //================================================================= #endregion #region ABC pattern // ABC pattern ==================================================== #region ABC long pattern // ABC long pattern =================================================================== if (abcPattern == AbcPatternMode.Long_And_Short || abcPattern == AbcPatternMode.Long) { if ((updateLow || newLow) && !abcLongChanceInProgress && lastLowRelation == Relation.Lower && curLowRelation == Relation.Higher && curLowPercent > abcMinRetracement && curLowPercent < abcMaxRetracement) { drawTag = swingCounterUp; abcLongChanceInProgress = true; entryLineStartBar = CurrentBar; patternCounter++; tmpCounter = swingCounterDn; abcSignals.Set(1); aBar = CurrentBar - lastLowBar; bBar = CurrentBar - curHighBar; cBar = CurrentBar - curLowBar; DrawLine("ABLineUp" + drawTag, AutoScale, aBar, lastLow, bBar, curHigh, abcZigZagColourUp, abcLineStyle, abcLineWidth); DrawLine("BCLineUp" + drawTag, AutoScale, bBar, curHigh, cBar, curLow, abcZigZagColourUp, abcLineStyle, abcLineWidth); DrawLine("ACLineUp" + drawTag, AutoScale, aBar, lastLow, cBar, curLow, abcZigZagColourUp, abcLineStyleRatio, abcLineWidthRatio); if (abcLabel) { DrawText("AUp" + drawTag, AutoScale, "A", aBar, lastLow, -abcTextOffsetLabel, abcTextColourUp, abcTextFont, StringAlignment.Center, Color.Transparent, Color.Transparent, 0); DrawText("BUp" + drawTag, AutoScale, "B", bBar, curHigh, abcTextOffsetLabel, abcTextColourUp, abcTextFont, StringAlignment.Center, Color.Transparent, Color.Transparent, 0); DrawText("CUp" + drawTag, AutoScale, "C", cBar, curLow, -abcTextOffsetLabel, abcTextColourUp, abcTextFont, StringAlignment.Center, Color.Transparent, Color.Transparent, 0); } entryLevel = curLow + Instrument.MasterInstrument.Round2TickSize((Math.Abs(curLowLength) * TickSize) / 100 * retracementEntryValue); entryLevelLine.Set(entryLevel); if (showEntryLine) DrawLine("EntryLine" + CurrentBar.ToString(), AutoScale, 1, entryLevelLine[0], 0, entryLevelLine[0], entryLineColourUp, entryLineStyle, entryLineWidth); if (useAbcAlerts) Alert("Alert_Abc_Long" + alertTag++.ToString(), priorityAbc, "ABC Long" + " (" + Bars.Period.ToString() + ")", fileNameAbcLong, 0, Color.White, Color.Blue); entryLong.Set(entryLevel); if (showRiskManagement) { double entryRM = entryLong[0]; double stopRM = curLow - 1 * TickSize; double target100RM = 0.0; if (swingSlope == 1) target100RM = curLow + lastHighLength * TickSize * abcTarget / 100; else target100RM = curLow + curHighLength * TickSize * abcTarget / 100; CalculateLongRisk(entryRM, stopRM, target100RM); } } if (abcLongChanceInProgress) { if (curLowPercent > abcMaxRetracement && tmpCounter == swingCounterDn) { abcLongChanceInProgress = false; RemoveDrawObject("ABLineUp" + drawTag.ToString()); RemoveDrawObject("BCLineUp" + drawTag.ToString()); RemoveDrawObject("ACLineUp" + drawTag.ToString()); RemoveDrawObject("AUp" + drawTag.ToString()); RemoveDrawObject("BUp" + drawTag.ToString()); RemoveDrawObject("CUp" + drawTag.ToString()); // Remove entryLevelLine (maybe remove more objects as drawn (COBC)) if (!showHistoricalEntryLine) { for (int index = 0; index < CurrentBar - entryLineStartBar + 1; index++) { RemoveDrawObject("EntryLine" + (CurrentBar - index).ToString()); } entryLineStartBar = 0; } } else if (dnFlip[0] && tmpCounter != swingCounterDn) { abcLongChanceInProgress = false; entryLineStartBar = 0; } else { if (updateLow && tmpCounter == swingCounterDn) { aBar = CurrentBar - lastLowBar; bBar = CurrentBar - curHighBar; cBar = CurrentBar - curLowBar; DrawLine("BCLineUp" + drawTag, AutoScale, bBar, curHigh, cBar, curLow, abcZigZagColourUp, abcLineStyle, abcLineWidth); DrawLine("ACLineUp" + drawTag, AutoScale, aBar, lastLow, cBar, curLow, abcZigZagColourUp, abcLineStyleRatio, abcLineWidthRatio); if (abcLabel) { DrawText("CUp" + drawTag, AutoScale, "C", cBar, curLow, -abcTextOffsetLabel, abcTextColourUp, abcTextFont, StringAlignment.Center, Color.Transparent, Color.Transparent, 0); } entryLevel = curLow + Instrument.MasterInstrument.Round2TickSize((Math.Abs(curLowLength) * TickSize) / 100 * retracementEntryValue); entryLevelLine.Set(entryLevel); if (showEntryLine) { if (entryLevelLine[1] == 0) DrawLine("EntryLine" + CurrentBar.ToString(), AutoScale, 1, entryLevelLine[0], 0, entryLevelLine[0], entryLineColourUp, entryLineStyle, entryLineWidth); else DrawLine("EntryLine" + CurrentBar.ToString(), AutoScale, 1, entryLevelLine[1], 0, entryLevelLine[0], entryLineColourUp, entryLineStyle, entryLineWidth); } entryLong.Set(entryLevel); if (showRiskManagement) { double entryRM = entryLong[0]; double stopRM = curLow - 1 * TickSize; double target100RM = 0.0; if (swingSlope == 1) target100RM = curLow + lastHighLength * TickSize * abcTarget / 100; else target100RM = curLow + curHighLength * TickSize * abcTarget / 100; CalculateLongRisk(entryRM, stopRM, target100RM); } } else if (FirstTickOfBar) { entryLevelLine.Set(entryLevel); if (showEntryLine) { if (entryLevelLine[1] == 0) DrawLine("EntryLine" + CurrentBar.ToString(), AutoScale, 1, entryLevelLine[0], 0, entryLevelLine[0], entryLineColourUp, entryLineStyle, entryLineWidth); else DrawLine("EntryLine" + CurrentBar.ToString(), AutoScale, 1, entryLevelLine[1], 0, entryLevelLine[0], entryLineColourUp, entryLineStyle, entryLineWidth); } } abcSignals.Set(1); bool abcLong = false; if (CalculateOnBarClose || Historical) { if (Close[0] > entryLevel) { entryLong.Set(Close[0]); abcLong = true; } } else { if (FirstTickOfBar && Open[0] > entryLevel) { entryLong.Set(Open[0]); abcLong = true; } } if (abcLong) { if (showEntryArrows) DrawArrowUp("AbcUp" + abcEntryTag++.ToString(), AutoScale, 0, Low[0] - yTickOffset * TickSize, abcTextColourUp); abcLongChanceInProgress = false; entryLineStartBar = 0; entryBar = CurrentBar; abcSignals.Set(2); if (showRiskManagement) { double entryRM = entryLong[0]; double stopRM = curLow - 1 * TickSize; double target100RM = 0.0; if (swingSlope == 1) target100RM = curLow + lastHighLength * TickSize * abcTarget / 100; else target100RM = curLow + curHighLength * TickSize * abcTarget / 100; CalculateLongRisk(entryRM, stopRM, target100RM); } if (useAbcEntryAlerts) Alert("Alert_Abc_Long_Entry" + alertTag++.ToString(), priorityAbcEntry, "ABC Long Entry" + " (" + Bars.Period.ToString() + ")", fileNameAbcLongEntry, 0, Color.Blue, Color.White); } } } } // End ABC long pattern =============================================================== #endregion #region ABC short pattern // ABC short pattern ================================================================== if (abcPattern == AbcPatternMode.Long_And_Short || abcPattern == AbcPatternMode.Short) { if ((updateHigh || newHigh) && !abcShortChanceInProgress && lastHighRelation == Relation.Higher && curHighRelation == Relation.Lower && curHighPercent > abcMinRetracement && curHighPercent < abcMaxRetracement) { drawTag = swingCounterDn; abcShortChanceInProgress = true; entryLineStartBar = CurrentBar; patternCounter++; tmpCounter = swingCounterUp; abcSignals.Set(-1); aBar = CurrentBar - lastHighBar; bBar = CurrentBar - curLowBar; cBar = CurrentBar - curHighBar; DrawLine("ABLineDn" + drawTag, AutoScale, aBar, lastHigh, bBar, curLow, abcZigZagColourDn, abcLineStyle, abcLineWidth); DrawLine("BCLineDn" + drawTag, AutoScale, bBar, curLow, cBar, curHigh, abcZigZagColourDn, abcLineStyle, abcLineWidth); DrawLine("ACLineDn" + drawTag, AutoScale, aBar, lastHigh, cBar, curHigh, abcZigZagColourDn, abcLineStyleRatio, abcLineWidthRatio); if (abcLabel) { DrawText("ADn" + drawTag, AutoScale, "A", aBar, lastHigh, abcTextOffsetLabel, abcTextColourDn, abcTextFont, StringAlignment.Center, Color.Transparent, Color.Transparent, 0); DrawText("BDn" + drawTag, AutoScale, "B", bBar, curLow, -abcTextOffsetLabel, abcTextColourDn, abcTextFont, StringAlignment.Center, Color.Transparent, Color.Transparent, 0); DrawText("CDn" + drawTag, AutoScale, "C", cBar, curHigh, abcTextOffsetLabel, abcTextColourDn, abcTextFont, StringAlignment.Center, Color.Transparent, Color.Transparent, 0); } entryLevel = curHigh - Instrument.MasterInstrument.Round2TickSize((curHighLength * TickSize) / 100 * retracementEntryValue); entryLevelLine.Set(entryLevel); if (showEntryLine) DrawLine("EntryLine" + CurrentBar.ToString(), AutoScale, 1, entryLevelLine[0], 0, entryLevelLine[0], entryLineColourDn, entryLineStyle, entryLineWidth); if (useAbcAlerts) Alert("Alert_Abc_Short" + alertTag++.ToString(), priorityAbc, "ABC Short" + " (" + Bars.Period.ToString() + ")", fileNameAbcShort, 0, Color.White, Color.Red); entryShort.Set(entryLevel); if (showRiskManagement) { double entryRM = entryShort[0]; double stopRM = curHigh + 1 * TickSize; double target100RM = 0.0; if (swingSlope == -1) target100RM = curHigh + lastLowLength * TickSize * abcTarget / 100; else target100RM = curHigh + curLowLength * TickSize * abcTarget / 100; CalculateShortRisk(entryRM, stopRM, target100RM); } } if (abcShortChanceInProgress) { if (curHighPercent > abcMaxRetracement && tmpCounter == swingCounterUp) { abcShortChanceInProgress = false; RemoveDrawObject("ABLineDn" + drawTag.ToString()); RemoveDrawObject("BCLineDn" + drawTag.ToString()); RemoveDrawObject("ACLineDn" + drawTag.ToString()); RemoveDrawObject("ADn" + drawTag.ToString()); RemoveDrawObject("BDn" + drawTag.ToString()); RemoveDrawObject("CDn" + drawTag.ToString()); // Remove entryLevelLine (maybe remove more objects as drawn (COBC)) if (!showHistoricalEntryLine) { for (int index = 0; index < CurrentBar - entryLineStartBar + 1; index++) { RemoveDrawObject("EntryLine" + (CurrentBar - index).ToString()); } entryLineStartBar = 0; } } else if (upFlip[0] && tmpCounter != swingCounterUp) { abcShortChanceInProgress = false; entryLineStartBar = 0; } else { if (updateHigh && tmpCounter == swingCounterUp) { aBar = CurrentBar - lastHighBar; bBar = CurrentBar - curLowBar; cBar = CurrentBar - curHighBar; DrawLine("BCLineDn" + drawTag, AutoScale, bBar, curLow, cBar, curHigh, abcZigZagColourDn, abcLineStyle, abcLineWidth); DrawLine("ACLineDn" + drawTag, AutoScale, aBar, lastHigh, cBar, curHigh, abcZigZagColourDn, abcLineStyleRatio, abcLineWidthRatio); if (abcLabel) { DrawText("CDn" + drawTag, AutoScale, "C", cBar, curHigh, abcTextOffsetLabel, abcTextColourDn, abcTextFont, StringAlignment.Center, Color.Transparent, Color.Transparent, 0); } entryLevel = curHigh - Instrument.MasterInstrument.Round2TickSize((curHighLength * TickSize) / 100 * retracementEntryValue); entryLevelLine.Set(entryLevel); if (showEntryLine) { if (entryLevelLine[1] == 0) DrawLine("EntryLine" + CurrentBar.ToString(), AutoScale, 1, entryLevelLine[0], 0, entryLevelLine[0], entryLineColourDn, entryLineStyle, entryLineWidth); else DrawLine("EntryLine" + CurrentBar.ToString(), AutoScale, 1, entryLevelLine[1], 0, entryLevelLine[0], entryLineColourDn, entryLineStyle, entryLineWidth); } entryShort.Set(entryLevel); if (showRiskManagement) { double entryRM = entryShort[0]; double stopRM = curHigh + 1 * TickSize; double target100RM = 0.0; if (swingSlope == -1) target100RM = curHigh + lastLowLength * TickSize * abcTarget / 100; else target100RM = curHigh + curLowLength * TickSize * abcTarget / 100; CalculateShortRisk(entryRM, stopRM, target100RM); } } else if (FirstTickOfBar) { entryLevelLine.Set(entryLevel); if (showEntryLine) { if (entryLevelLine[1] == 0) DrawLine("EntryLine" + CurrentBar.ToString(), AutoScale, 1, entryLevelLine[0], 0, entryLevelLine[0], entryLineColourDn, entryLineStyle, entryLineWidth); else DrawLine("EntryLine" + CurrentBar.ToString(), AutoScale, 1, entryLevelLine[1], 0, entryLevelLine[0], entryLineColourDn, entryLineStyle, entryLineWidth); } } abcSignals.Set(-1); bool abcShort = false; if (CalculateOnBarClose || Historical) { if (Close[0] < entryLevel) { entryShort.Set(Close[0]); abcShort = true; } } else { if (FirstTickOfBar && Open[0] < entryLevel) { entryShort.Set(Open[0]); abcShort = true; } } if (abcShort) { if (showEntryArrows) DrawArrowDown("AbcDn" + abcEntryTag++.ToString(), AutoScale, 0, High[0] + yTickOffset * TickSize, abcTextColourDn); abcShortChanceInProgress = false; entryLineStartBar = 0; entryBar = CurrentBar; abcSignals.Set(-2); if (showRiskManagement) { double entryRM = entryShort[0]; double stopRM = curHigh + 1 * TickSize; double target100RM = 0.0; if (swingSlope == -1) target100RM = curHigh + lastLowLength * TickSize * abcTarget / 100; else target100RM = curHigh + curLowLength * TickSize * abcTarget / 100; CalculateShortRisk(entryRM, stopRM, target100RM); } if (useAbcEntryAlerts) Alert("Alert_Abc_Short_Entry" + alertTag++.ToString(), priorityAbcEntry, "ABC Short Entry" + " (" + Bars.Period.ToString() + ")", fileNameAbcShortEntry, 0, Color.Red, Color.Black); } } } } // End ABC short pattern ============================================================== #endregion // End ABC pattern ================================================ #endregion #region Divergence if (divergenceMode != DivergenceMode.False) { if (divergenceDirection != DivergenceDirection.Short) { if (newHigh == true && updateHigh == false) { drawTagDivDn++; divLastSwing = lastHigh; divLastOscValue = Math.Max(divergenceDataHigh[CurrentBar - lastHighBar + 1], Math.Max(divergenceDataHigh[CurrentBar - lastHighBar], divergenceDataHigh[CurrentBar - lastHighBar - 1])); } if (newHigh == true || updateHigh == true) { divCurSwing = curHigh; divCurOscValue = Math.Max(divergenceDataHigh[CurrentBar - curHighBar], divergenceDataHigh[CurrentBar - curHighBar + 1]); if (showDivergenceHidden == true) { if (divLastSwing > divCurSwing && divLastOscValue < divCurOscValue) { DrawLine("DivHidSignalDn" + drawTagDivDn, AutoScale, CurrentBar - lastHighBar, lastHigh, CurrentBar - curHighBar, curHigh, divDnLineColour, divDnLineStyle, divDnLineWidth); int textDivBarAgo = Convert.ToInt32(CurrentBar - (lastHighBar + curHighBar) / 2); double textDivPrice = Instrument.MasterInstrument.Round2TickSize( (lastHigh + curHigh) / 2); DrawText("DivHidTextDn" + drawTagDivDn, AutoScale, "hDiv", textDivBarAgo, textDivPrice, 10, divDnLineColour, textFont, StringAlignment.Center, Color.Transparent, Color.Transparent, 0); divHiddenShortActive = true; divSignal.Set(-2); } else { RemoveDrawObject("DivHidSignalDn" + drawTagDivDn); RemoveDrawObject("DivHidTextDn" + drawTagDivDn); divHiddenShortActive = false; } } if (showDivergenceRegular == true) { if (divLastSwing < divCurSwing && divLastOscValue > divCurOscValue) { DrawLine("DivSignalDn" + drawTagDivDn, AutoScale, CurrentBar - lastHighBar, lastHigh, CurrentBar - curHighBar, curHigh, divDnLineColour, divDnLineStyle, divDnLineWidth); int textDivBarAgo = Convert.ToInt32(CurrentBar - (lastHighBar + curHighBar) / 2); double textDivPrice = Instrument.MasterInstrument.Round2TickSize( (lastHigh + curHigh) / 2); DrawText("DivRegTextDn" + drawTagDivDn, AutoScale, "rDiv", textDivBarAgo, textDivPrice, 10, divDnLineColour, textFont, StringAlignment.Center, Color.Transparent, Color.Transparent, 0); divRegularShortActive = true; divSignal.Set(-1); } else { RemoveDrawObject("DivSignalDn" + drawTagDivDn); RemoveDrawObject("DivRegTextDn" + drawTagDivDn); divRegularShortActive = false; } } } } if (divergenceDirection != DivergenceDirection.Long) { if (newLow == true && updateLow == false) { drawTagDivUp++; divLastSwing = lastLow; divLastOscValue = Math.Min(divergenceDataLow[CurrentBar - lastLowBar + 1], Math.Min(divergenceDataLow[CurrentBar - lastLowBar], divergenceDataLow[CurrentBar - lastLowBar - 1])); } if (newLow == true || updateLow == true) { divCurSwing = curLow; divCurOscValue = Math.Min(divergenceDataLow[CurrentBar - curLowBar], divergenceDataLow[CurrentBar - curLowBar + 1]); if (showDivergenceHidden == true) { if (divLastSwing < divCurSwing && divLastOscValue > divCurOscValue) { DrawLine("DivHidSignalup" + drawTagDivUp, AutoScale, CurrentBar - lastLowBar, lastLow, CurrentBar - curLowBar, curLow, divUpLineColour, divUpLineStyle, divUpLineWidth); int textDivBarAgo = Convert.ToInt32(CurrentBar - (lastLowBar + curLowBar) / 2); double textDivPrice = Instrument.MasterInstrument.Round2TickSize( (lastLow + curLow) / 2); DrawText("DivHidTextUp" + drawTagDivUp, AutoScale, "hDiv", textDivBarAgo, textDivPrice, -10, divUpLineColour, textFont, StringAlignment.Center, Color.Transparent, Color.Transparent, 0); divHiddenLongActive = true; divSignal.Set(2); } else { RemoveDrawObject("DivHidSignalup" + drawTagDivUp); RemoveDrawObject("DivHidTextUp" + drawTagDivUp); divHiddenLongActive = false; } } if (showDivergenceRegular == true) { if (divLastSwing > divCurSwing && divLastOscValue < divCurOscValue) { DrawLine("DivSignalUp" + drawTagDivUp, AutoScale, CurrentBar - lastLowBar, lastLow, CurrentBar - curLowBar, curLow, divUpLineColour, divUpLineStyle, divUpLineWidth); int textDivBarAgo = Convert.ToInt32(CurrentBar - (lastLowBar + curLowBar) / 2); double textDivPrice = Instrument.MasterInstrument.Round2TickSize( (lastLow + curLow) / 2); DrawText("DivRegTextUp" + drawTagDivUp, AutoScale, "rDiv", textDivBarAgo, textDivPrice, -10, divUpLineColour, textFont, StringAlignment.Center, Color.Transparent, Color.Transparent, 0); divRegularLongActive = true; divSignal.Set(1); } else { RemoveDrawObject("DivSignalUp" + drawTagDivUp); RemoveDrawObject("DivRegTextUp" + drawTagDivUp); divRegularLongActive = false; } } } } if (dnFlip[0] == true) { if (divRegularShortActive == true) { divRegularShortActive = false; divSignal.Set(-3); } else if (divHiddenShortActive == true) { divHiddenShortActive = false; divSignal.Set(-4); } } else if (upFlip[0] == true) { if (divRegularLongActive == true) { divRegularLongActive = false; divSignal.Set(3); } else if (divHiddenLongActive == true) { divHiddenLongActive = false; divSignal.Set(4); } } } #endregion }