Kopiert von hier, da es hier besser hinpasst

Meine umfangreiche Version für MC finde ich grad nicht mehr da war allerhand mit drin...

 

Finde gerade nur meine alte Version für NT

 

 

Es handelt sich um eine vollautomatische Strategie, die Richtung der 00-er Linien tradet, mit SL/TP und Abstand einstellbar.

Zuvor das passende Instrument in den Einstellungen auswählen (FDAX, FGBL, FX). 1 Pip = ein üblicher Pip in dem Instrument. Bei Abstand > 50 (also mehr als über die Mitte zwischen zwei 00er) wird der Bstand auf 50 gesetzt.

 

eHenNNv8

#region Using declarations
using System;
using System.ComponentModel;
using System.Diagnostics;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Xml.Serialization;
using NinjaTrader.Cbi;
using NinjaTrader.Data;
using NinjaTrader.Indicator;
using NinjaTrader.Gui.Chart;
using NinjaTrader.Strategy;
#endregion

// This namespace holds all strategies and is required. Do not change it.
namespace NinjaTrader.Strategy
{
   /// <summary>
   /// Enter the description of your strategy here
   /// </summary>
   [Description("NullNull - Strategie: Tradet x % von einer 00-Linie Richtung 00, für FX und Future geeignet.")]
   public class eHenNNv8 : Strategy
   {
       #region Variables
       // Wizard generated variables
           private int lots = 1; 
           private int abstand = 10; 
           private int sLfix = 20; 			// SLfix, ggf. *2 bei FX
           private int tPfix = 10; 			// TPfix, ggf. *2 bei FX
		private double puffer = 0.5;		// Puffer beim Einstiegskurs in Pips
		private bool fGBL = false;
		private bool fXvierstellig = false;
		private bool fDAX = false;
		private bool goLong = true;
		private bool goShort = true;
		private int ruecksetzen = 40;		// Wo traden auf =true zurückgesetzt werden soll nach Positionseingang

       // User defined variables (add any user defined variables below)
		int lotswert;
		double askkurs;
		double bidkurs;
		bool tradenerlauben = false;
       #endregion

       /// <summary>
       /// This method is used to configure the strategy and is called once before any strategy method is called.
       /// </summary>
       protected override void Initialize()
       {
        			
		CalculateOnBarClose = false;
		
		lotswert=Convert.ToInt32(lots*100000); //rechnet er nur bei FX
		
       }

       /// <summary>
       /// Called on each bar update event (incoming tick)
       /// </summary>
       protected override void OnBarUpdate()
       {
	
	
	// Sicherheitscheck: setzt "Ruecksetzen" auf 51, da ab 50 sonst das Ruecksetzen-System nicht mehr funktioniert  
	if (ruecksetzen >= 51)
	{
		ruecksetzen = 50;
	}

	
	
// Wenn FGBL aktiviert ist, dann...
//################################################################################################################################
	if (FGBL && !FDAX && !FXvierstellig) 
	{

		// Er rechnet aus, wo die 00-Linien sind beim FGBL
		askkurs = (GetCurrentAsk() * 100);
		bidkurs = (GetCurrentBid() * 100);
		
		// Er setzten Tradenerlauben auf true wenn Kurs in der Mitte zwischen 40 und 60 war
		if ((askkurs%100>=ruecksetzen && askkurs%100<=100-ruecksetzen) || (bidkurs%100>=ruecksetzen && bidkurs%100<=100-ruecksetzen))
		{
			tradenerlauben = true;
		}
		
		// Wenn Restwert >= 100 minus Abstand - Puffer && etc... (100 beim Abstand steht für Pips zwischen zwei 00ern!) 
		//...long #######################
		if (askkurs%100 >= (100 - Abstand - Puffer) && askkurs%100 <= (100 - Abstand + Puffer) && tradenerlauben && GoLong)
		{ 
			EnterLong(lots, "");
			SetProfitTarget("", CalculationMode.Ticks, (TPfix));
           	SetStopLoss("", CalculationMode.Ticks, (SLfix), false);
			tradenerlauben = false;
		}
		//...Wenn nur Long oder nur Short aktiviert ist, verhindert das hier dass Richtung 00 gehandelt wird wenn 00 grad aus falscher Richtung durchbrochen worden ist 
		if (askkurs%100 >= (100 - Abstand - Puffer) && askkurs%100 <= (100 - Abstand + Puffer) && tradenerlauben && !GoLong)
		{
			tradenerlauben = false;
		}
		
		//...short #######################
		if (bidkurs%100 >= (Abstand - Puffer) && bidkurs%100 <= (Abstand + Puffer) && tradenerlauben && GoShort)
		{ 
			EnterShort(lots, "");
			SetProfitTarget("", CalculationMode.Ticks, (TPfix));
           	SetStopLoss("", CalculationMode.Ticks, (SLfix), false);
			tradenerlauben = false;
		}
		//...Wenn nur Long oder nur Short aktiviert ist, verhindert das hier dass Richtung 00 gehandelt wird wenn 00 grad aus falscher Richtung durchbrochen worden ist
		if (bidkurs%100 >= (Abstand - Puffer) && bidkurs%100 <= (Abstand + Puffer) && tradenerlauben && !GoShort)
		{
			tradenerlauben = false;
		}
	}	

	
// Wenn FDAX aktiviert ist, dann...
//################################################################################################################################ 
	if (FDAX && !FGBL && !FXvierstellig)
	{

		// Er rechnet aus, wo die 00-Linien sind beim FDAX
		askkurs = (GetCurrentAsk() * 1);
		bidkurs = (GetCurrentBid() * 1);
		
		// Er setzten Tradenerlauben auf true wenn Kurs in der Mitte zwischen 40 und 60 war
		if ((askkurs%100>=ruecksetzen && askkurs%100<=100-ruecksetzen) || (bidkurs%100>=ruecksetzen && bidkurs%100<=100-ruecksetzen))
		{
			tradenerlauben = true;
		}
		
		// Wenn Restwert >= 100 minus Abstand - Puffer && etc... (100 beim Abstand steht für Pips zwischen zwei 00ern!) 
		//...long #######################
		if (askkurs%100 >= (100 - Abstand - Puffer) && askkurs%100 <= (100 - Abstand + Puffer) && tradenerlauben && GoLong)
		{ 
			EnterLong(lots, "");
			SetProfitTarget("", CalculationMode.Ticks, (TPfix*2));
           	SetStopLoss("", CalculationMode.Ticks, (SLfix*2), false);
			tradenerlauben = false;
		}
		//...Wenn nur Long oder nur Short aktiviert ist, verhindert das hier dass Richtung 00 gehandelt wird wenn 00 grad aus falscher Richtung durchbrochen worden ist
		if (askkurs%100 >= (100 - Abstand - Puffer) && askkurs%100 <= (100 - Abstand + Puffer) && tradenerlauben && !GoLong)
		{
			tradenerlauben = false;
		}
		
		//...short #######################
		if (bidkurs%100 >= (Abstand - Puffer) && bidkurs%100 <= (Abstand + Puffer) && tradenerlauben && GoShort)
		{ 
			EnterShort(lots, "");
			SetProfitTarget("", CalculationMode.Ticks, (TPfix*2));
           	SetStopLoss("", CalculationMode.Ticks, (SLfix*2), false);
			tradenerlauben = false;
		}
		//...Wenn nur Long oder nur Short aktiviert ist, verhindert das hier dass Richtung 00 gehandelt wird wenn 00 grad aus falscher Richtung durchbrochen worden ist
		if (bidkurs%100 >= (Abstand - Puffer) && bidkurs%100 <= (Abstand + Puffer) && tradenerlauben && !GoShort)
		{
			tradenerlauben = false;
		}
	}	
	

// Wenn FX aktiviert ist, dann...
//################################################################################################################################
	if (FXvierstellig && !FDAX && !FGBL)
	{

		// Er rechnet aus, wo die 00-Linien sind (bei 4stelligen Kursen (FX)
		askkurs = (GetCurrentAsk() * 10000);
		bidkurs = (GetCurrentBid() * 10000);
		
		// Er setzten Tradenerlauben auf true wenn Kurs in der Mitte zwischen 40 und 60 war
		if ((askkurs%100>=ruecksetzen && askkurs%100<=100-ruecksetzen) || (bidkurs%100>=ruecksetzen && bidkurs%100<=100-ruecksetzen))
		{
			tradenerlauben = true;
		}
		
		// Wenn Restwert >= 100 minus Abstand - Puffer && etc... (100 beim Abstand steht für Pips zwischen zwei 00ern!) 
		//...long #######################
		if (askkurs%100 >= (100 - Abstand - Puffer) && askkurs%100 <= (100 - Abstand + Puffer) && tradenerlauben && GoLong)
		{ 
			EnterLong(lotswert, "");
			SetProfitTarget("", CalculationMode.Ticks, (TPfix*2));
           	SetStopLoss("", CalculationMode.Ticks, (SLfix*2), false);
			tradenerlauben = false;
		}
		//...Wenn nur Long oder nur Short aktiviert ist, verhindert das hier dass Richtung 00 gehandelt wird wenn 00 grad aus falscher Richtung durchbrochen worden ist
		if (askkurs%100 >= (100 - Abstand - Puffer) && askkurs%100 <= (100 - Abstand + Puffer) && tradenerlauben && !GoLong)
		{
			tradenerlauben = false;
		}
		
		//...short #######################
		if (bidkurs%100 >= (Abstand - Puffer) && bidkurs%100 <= (Abstand + Puffer) && tradenerlauben && GoShort)
		{ 
			EnterShort(lotswert, "");
			SetProfitTarget("", CalculationMode.Ticks, (TPfix*2));
           	SetStopLoss("", CalculationMode.Ticks, (SLfix*2), false);
			tradenerlauben = false;
		}
		//...Wenn nur Long oder nur Short aktiviert ist, verhindert das hier dass Richtung 00 gehandelt wird wenn 00 grad aus falscher Richtung durchbrochen worden ist
		if (bidkurs%100 >= (Abstand - Puffer) && bidkurs%100 <= (Abstand + Puffer) && tradenerlauben && !GoShort)
		{
			tradenerlauben = false;
		}
	}	
	
	
       }

       #region Properties
	
// Welches Instrument (taucht nicht unter "Parameters" auf!)	
	
	[Description("FGBL: Bund Future")]
       [Category("\tInstrument")]
       public bool FGBL
       {
           get { return fGBL; }
           set { fGBL = value; }
       }
			
	[Description("FDAX: Future Dax")]
       [Category("\tInstrument")]
       public bool FDAX
       {
           get { return fDAX; }
           set { fDAX = value; }
       }
	
	[Description("Bei FX vierstellig auf true stellen (EURUSD, EURCHF,...)")]
       [Category("\tInstrument")]
       public bool FXvierstellig
       {
           get { return fXvierstellig; }
           set { fXvierstellig = value; }
       }
	
// Long und / oder Short gehen	
	
	[Description("Gehe Long")]
       [Category("Parameters")]
       public bool GoLong
       {
           get { return goLong; }
           set { goLong = value; }
       }
			
	[Description("Gehe Short")]
       [Category("Parameters")]
       public bool GoShort
       {
           get { return goShort; }
           set { goShort = value; }
       }
	
// Zu optimierende Parameter	
	
       [Description("Bei FX ist 1 Lot gleich 100.000")]
       [GridCategory("Parameters")]
       public int Lots
       {
           get { return lots; }
           set { lots = Math.Max(1, value); }
       }

       [Description("10 steht für 10 % von der Differenz zweier Nullerkursen, 15 für 15 % etc! Macht nur Sinn zwischen 1 und 40")]
       [GridCategory("Parameters")]
       public int Abstand
       {
           get { return abstand; }
           set { abstand = Math.Max(1, value); }
       }
           
       [Description("Fester SL in Pips")]
       [GridCategory("Parameters")]
       public int SLfix
       {
           get { return sLfix; }
           set { sLfix = Math.Max(1, value); }
       }

       [Description("Fester TP in Pips")]
       [GridCategory("Parameters")]
       public int TPfix
       {
           get { return tPfix; }
           set { tPfix = Math.Max(1, value); }
       }
       
	[Description("Puffer beim Einstiegskurs in Pips (Abstand + und - Puffer), macht ab 0,5 Sinn")]
       [GridCategory("Parameters")]
       public double Puffer
       {
           get { return puffer; }
           set { puffer = Math.Max(0.0, value); }
       }
	
	[Description("Abstand von 00 nachdem Traden wieder erlaubt werden soll")]
       [GridCategory("Parameters")]
       public int Ruecksetzen
       {
           get { return ruecksetzen; }
           set { ruecksetzen = Math.Max(1, value); }
       }
       #endregion
   }
}

 

eHenNNv8.zip

Ich weiß, es ist nicht einfach, sich in anderen Codes hereinzulesen. Ich glaub das war auch einer meiner ersten NT-Codes. Ist also etwas primitiv geschrieben.

Die Aufteilung nach den Instrumenten habe ich gemacht, da es sich so leichter auf verschiedenen Märkten optimieren (Potenzialauslotung) ließ.

 

 

Wenn jemand Ergänzungen oder Tipps hat, nur zu!

Mein Fazit von dieser Strategie war, dass man es wirklich nur als Codebaustein nutzen kann, aber nicht als eigenständige Strategie.

In der MultiChartsversion hatte ich das ganze noch um viele Funktionen erweitert: wie oft eine 00er angestrebt werden kann bevor erst die nächste erreicht werden muss, MM, dynamische TP/SL nach verschiedenen Kriterien etc.