Hier ist eine einfache Strategie für de40 und vgl

This topic has 1 reply, 2 voices, and was last updated 6 hours ago by LucasBest.

Viewing 2 posts - 1 through 2 (of 2 total)

11/30/2025 at 12:11 PM #254094

JohnScher

Ich frage ob es jmd in PRT-Sprache übersetzen kann
im mt4 gab es keine Kompilierfehler
die Idee dahinter ist wirklich einfach
warten wir auf ein Corona 2.0
LG

//+——————————————————————+
//| Expert Advisor: 5%.mq4 |
//| Purpose: Place stacked Buy Limits below ATH – X%, TP = ATH + 1 |
//| Logic: ATH from H1, check hourly at H1 close |
//| Extension: ATH calculation by time window (days) |
//+——————————————————————+

#property strict
#property show_inputs
#property copyright “DKATLE 2025”
#property link “https://www.dkatle.com”

input string TradeComment = “%5”; // Unique text for orders

// — Inputs
input double Lots = 0.1; // Lot size per order
input int Slippage = 10; // Slippage
input int LookbackDays = 365; // Time window in days for ATH
input int MagicNumber = 12345; // Unique ID for this EA

// Stacking levels (percent below ATH)
input double Level1 = 5.0;
input double Level2 = 10.0;
input double Level3 = 15.0;
input double Level4 = 20.0;
input double Level5 = 25.0;
input double Level6 = 30.0;
input double Level7 = 35.0;
input double Level8 = 40.0;
input double Level9 = 45.0;

double lastATH = -1;
datetime lastHourBar = 0;

//— Calculate ATH from H1 candles within LookbackDays
double GetLastATH(string sym, int daysBack)
{
int totalBars = iBars(sym, PERIOD_H1);
if(totalBars <= 0) return -1;

double ath = -DBL_MAX;
datetime cutoff = TimeCurrent() – daysBack * 24 * 60 * 60;

for(int i = 0; i < totalBars; i++)
{
datetime barTime = iTime(sym, PERIOD_H1, i);
if(barTime < cutoff) break;
double high = iHigh(sym, PERIOD_H1, i);
if(high > ath) ath = high;
}
return ath;
}

//— Delete pending Buy Limits for current symbol & MagicNumber
void DeletePendingBuyLimits(string sym)
{
for(int i = OrdersTotal() – 1; i >= 0; i–)
{
if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
{
if(OrderSymbol() == sym && OrderType() == OP_BUYLIMIT && OrderMagicNumber() == MagicNumber)
{
if(!OrderDelete(OrderTicket()))
Print(“OrderDelete error “, GetLastError(), ” for ticket “, OrderTicket());
}
}
}
}

//— Check if a BuyLimit with same price already exists
bool BuyLimitExists(string sym, double price)
{
for(int i = OrdersTotal() – 1; i >= 0; i–)
{
if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
{
if(OrderSymbol() == sym && OrderType() == OP_BUYLIMIT && OrderMagicNumber() == MagicNumber)
{
if(MathAbs(OrderOpenPrice() – price) < Point*0.5)
return true;
}
}
}
return false;
}

//— Price validation and normalization
bool ValidateAndNormalizePrices(string sym, double &price, double &tp)
{
int digits = (int)MarketInfo(sym, MODE_DIGITS);
double point = MarketInfo(sym, MODE_POINT);
int stopLevel = (int)MarketInfo(sym, MODE_STOPLEVEL);
double ask = MarketInfo(sym, MODE_ASK);
double minDist = stopLevel * point;

price = NormalizeDouble(price, digits);
tp = NormalizeDouble(tp, digits);

if(price >= ask – minDist)
{
Print(“Invalid BuyLimit price “, price, ” (Ask “, ask, “, minDist “, minDist, “)”);
return false;
}

if(tp <= price + minDist)
{
tp = price + MathMax(minDist, point);
tp = NormalizeDouble(tp, digits);
Print(“TP adjusted to “, tp, ” (minDist “, minDist, “)”);
}

return true;
}

//— Place new stacked Buy Limits
void PlaceStackedBuyLimits(string sym, double ath)
{
double baseTp = ath + MarketInfo(sym, MODE_POINT);

double levels[9];
levels[0] = Level1;
levels[1] = Level2;
levels[2] = Level3;
levels[3] = Level4;
levels[4] = Level5;
levels[5] = Level6;
levels[6] = Level7;
levels[7] = Level8;
levels[8] = Level9;

for(int i = 0; i < 9; i++)
{
double pct = levels[i];
if(pct <= 0.0) continue;

double buyPrice = ath * (1.0 – pct / 100.0);
double tp = baseTp;

if(!ValidateAndNormalizePrices(sym, buyPrice, tp))
{
Print(“Skipped: Level “, pct, “% (invalid price)”);
continue;
}

if(BuyLimitExists(sym, buyPrice))
{
Print(“Skipped: Level “, pct, “% (duplicate order at “, buyPrice, “)”);
continue;
}

int ticket = OrderSend(
sym, OP_BUYLIMIT, Lots, buyPrice, Slippage,
0, tp,
TradeComment + ” ATH-” + DoubleToString(pct, 1) + “% TP=ATH+1”,
MagicNumber, 0, clrBlue
);
if(ticket < 0)
{
int err = GetLastError();
Print(“OrderSend error “, err, ” at level “, pct, “% (price “, buyPrice, “, TP “, tp, “)”);
}
}
}

//— Initialization
int OnInit()
{
string sym = _Symbol;
lastATH = GetLastATH(sym, LookbackDays);

if(lastATH > 0)
{
DeletePendingBuyLimits(sym);
PlaceStackedBuyLimits(sym, lastATH);
}
else
{
Print(“OnInit: No valid ATH found (Symbol “, sym, “).”);
}

lastHourBar = iTime(sym, PERIOD_H1, 0);
return(INIT_SUCCEEDED);
}

//— OnTick: check only after H1 candle closes
void OnTick()
{
string sym = _Symbol;
datetime bt = iTime(sym, PERIOD_H1, 0);

if(bt != lastHourBar && TimeCurrent() > bt)
{
lastHourBar = bt;

double ath = GetLastATH(sym, LookbackDays);
if(ath > 0 && ath > lastATH)
{
lastATH = ath;
DeletePendingBuyLimits(sym);
PlaceStackedBuyLimits(sym, ath);
}
}
}

JohnScher

Participant

Topics: 45

Replies: 338

Been thanked: 87 times

11/30/2025 at 4:36 PM #254105

LucasBest

// ==============================================
// ATH stacked buys sous ATH -X%  (version PRT)
// - Timeframe : 1 heure (appliquer le système sur H1)
// - ATH sur LookbackDays (~ jours * 24 barres)
// - On empile des achats à chaque palier de % sous l'ATH
// - TP global = ATH + 1 point
// ==============================================

DEFPARAM CumulateOrders = True
DEFPARAM PreLoadBars = 10000

// ---------- Paramètres utilisateur ----------

// Taille de base par niveau
UnitsPerLevel = 1

// Fenêtre de calcul de l'ATH (en jours approx.)
LookbackDays = 365

// Niveaux en % sous l'ATH
Level1 = 5.0
Level2 = 10.0
Level3 = 15.0
Level4 = 20.0
Level5 = 25.0
Level6 = 30.0
Level7 = 35.0
Level8 = 40.0
Level9 = 45.0

// ---------- Variables internes ----------

ONCE LastAth = 0
ONCE Initialised = 0

// ---------- Calcul de l'ATH sur la fenêtre LookbackDays ----------

// Approximation : 1 jour ≈ 24 bougies H1
BarsPerDay = 24
BarsLookback = LookbackDays * BarsPerDay

IF BarIndex > 0 THEN
Ath = High
BarsToScan = BarsLookback
IF BarsToScan > BarIndex THEN
BarsToScan = BarIndex
ENDIF

FOR i = 1 TO BarsToScan DO
ThisHigh = High[i]
IF ThisHigh > Ath THEN
Ath = ThisHigh
ENDIF
NEXT
ELSE
Ath = High
ENDIF

// Initialisation & mise à jour de l'ATH
IF Ath > 0 THEN
IF Initialised = 0 THEN
LastAth = Ath
Initialised = 1
ELSE
IF Ath > LastAth THEN
// Nouvel ATH : on remonte la référence
LastAth = Ath
ENDIF
ENDIF
ENDIF

// Si l'ATH n'est pas encore initialisé, on ne fait rien
IF Initialised = 0 THEN
quit
ENDIF

// ---------- Calcul du TP global ----------

BaseTp = LastAth + PointSize

// ---------- Calcul des prix de niveaux ----------

// On ne place des niveaux que si le % > 0

PriceLevel1 = 0
PriceLevel2 = 0
PriceLevel3 = 0
PriceLevel4 = 0
PriceLevel5 = 0
PriceLevel6 = 0
PriceLevel7 = 0
PriceLevel8 = 0
PriceLevel9 = 0

IF Level1 > 0 THEN
PriceLevel1 = LastAth * (1 - Level1 / 100)
ENDIF

IF Level2 > 0 THEN
PriceLevel2 = LastAth * (1 - Level2 / 100)
ENDIF

IF Level3 > 0 THEN
PriceLevel3 = LastAth * (1 - Level3 / 100)
ENDIF

IF Level4 > 0 THEN
PriceLevel4 = LastAth * (1 - Level4 / 100)
ENDIF

IF Level5 > 0 THEN
PriceLevel5 = LastAth * (1 - Level5 / 100)
ENDIF

IF Level6 > 0 THEN
PriceLevel6 = LastAth * (1 - Level6 / 100)
ENDIF

IF Level7 > 0 THEN
PriceLevel7 = LastAth * (1 - Level7 / 100)
ENDIF

IF Level8 > 0 THEN
PriceLevel8 = LastAth * (1 - Level8 / 100)
ENDIF

IF Level9 > 0 THEN
PriceLevel9 = LastAth * (1 - Level9 / 100)
ENDIF

// ---------- Taille "théorique" à détenir selon la baisse vs ATH ----------

// Idée :
// - On compte combien de niveaux ont été atteints par le prix actuel (Close)
// - Pour chaque niveau atteint, on veut UnitsPerLevel en plus
// - On n'allège jamais sur rebond : la taille cible ne fait qu'augmenter

TargetSize = 0

IF PriceLevel1 > 0 AND Close <= PriceLevel1 THEN
TargetSize = TargetSize + UnitsPerLevel
ENDIF

IF PriceLevel2 > 0 AND Close <= PriceLevel2 THEN
TargetSize = TargetSize + UnitsPerLevel
ENDIF

IF PriceLevel3 > 0 AND Close <= PriceLevel3 THEN
TargetSize = TargetSize + UnitsPerLevel
ENDIF

IF PriceLevel4 > 0 AND Close <= PriceLevel4 THEN
TargetSize = TargetSize + UnitsPerLevel
ENDIF

IF PriceLevel5 > 0 AND Close <= PriceLevel5 THEN
TargetSize = TargetSize + UnitsPerLevel
ENDIF

IF PriceLevel6 > 0 AND Close <= PriceLevel6 THEN
TargetSize = TargetSize + UnitsPerLevel
ENDIF

IF PriceLevel7 > 0 AND Close <= PriceLevel7 THEN
TargetSize = TargetSize + UnitsPerLevel
ENDIF

IF PriceLevel8 > 0 AND Close <= PriceLevel8 THEN
TargetSize = TargetSize + UnitsPerLevel
ENDIF

IF PriceLevel9 > 0 AND Close <= PriceLevel9 THEN
TargetSize = TargetSize + UnitsPerLevel
ENDIF

// On ne réduit jamais la taille : si le prix remonte,
// on garde au moins la taille déjà détenue.
CurrentSize = COUNTOFPOSITION

IF TargetSize < CurrentSize THEN
TargetSize = CurrentSize
ENDIF

// ---------- Entrées supplémentaires (empilement) ----------

AdditionalSize = TargetSize - CurrentSize

IF AdditionalSize > 0 THEN
// On place / met à jour le TP global pour toutes les positions longues
IF BaseTp > 0 THEN
SET TARGET PRICE BaseTp
ENDIF

BUY AdditionalSize SHARES AT MARKET
ENDIF

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

// ==============================================

// ATH stacked buys sous ATH -X% (version PRT)

// - Timeframe : 1 heure (appliquer le système sur H1)

// - ATH sur LookbackDays (~ jours * 24 barres)

// - On empile des achats à chaque palier de % sous l'ATH

// - TP global = ATH + 1 point

// ==============================================

DEFPARAM CumulateOrders = True

DEFPARAM PreLoadBars = 10000

// ---------- Paramètres utilisateur ----------

// Taille de base par niveau

UnitsPerLevel = 1

// Fenêtre de calcul de l'ATH (en jours approx.)

LookbackDays = 365

// Niveaux en % sous l'ATH

Level1 = 5.0

Level2 = 10.0

Level3 = 15.0

Level4 = 20.0

Level5 = 25.0

Level6 = 30.0

Level7 = 35.0

Level8 = 40.0

Level9 = 45.0

// ---------- Variables internes ----------

ONCE LastAth = 0

ONCE Initialised = 0

// ---------- Calcul de l'ATH sur la fenêtre LookbackDays ----------

// Approximation : 1 jour ≈ 24 bougies H1

BarsPerDay = 24

BarsLookback = LookbackDays * BarsPerDay

IF BarIndex > 0 THEN

Ath = High

BarsToScan = BarsLookback

IF BarsToScan > BarIndex THEN

BarsToScan = BarIndex

ENDIF

FOR i = 1 TO BarsToScan DO

ThisHigh = High[i]

IF ThisHigh > Ath THEN

Ath = ThisHigh

ENDIF

ELSE

Ath = High

ENDIF

// Initialisation & mise à jour de l'ATH

IF Ath > 0 THEN

IF Initialised = 0 THEN

LastAth = Ath

Initialised = 1

ELSE

IF Ath > LastAth THEN

// Nouvel ATH : on remonte la référence

LastAth = Ath

ENDIF

// Si l'ATH n'est pas encore initialisé, on ne fait rien

IF Initialised = 0 THEN

quit

ENDIF

// ---------- Calcul du TP global ----------

BaseTp = LastAth + PointSize

// ---------- Calcul des prix de niveaux ----------

// On ne place des niveaux que si le % > 0

PriceLevel1 = 0

PriceLevel2 = 0

PriceLevel3 = 0

PriceLevel4 = 0

PriceLevel5 = 0

PriceLevel6 = 0

PriceLevel7 = 0

PriceLevel8 = 0

PriceLevel9 = 0

IF Level1 > 0 THEN

PriceLevel1 = LastAth * (1 - Level1 / 100)

ENDIF

IF Level2 > 0 THEN

PriceLevel2 = LastAth * (1 - Level2 / 100)

ENDIF

IF Level3 > 0 THEN

PriceLevel3 = LastAth * (1 - Level3 / 100)

ENDIF

IF Level4 > 0 THEN

PriceLevel4 = LastAth * (1 - Level4 / 100)

ENDIF

IF Level5 > 0 THEN

PriceLevel5 = LastAth * (1 - Level5 / 100)

ENDIF

IF Level6 > 0 THEN

PriceLevel6 = LastAth * (1 - Level6 / 100)

ENDIF

IF Level7 > 0 THEN

PriceLevel7 = LastAth * (1 - Level7 / 100)

ENDIF

IF Level8 > 0 THEN

PriceLevel8 = LastAth * (1 - Level8 / 100)

ENDIF

IF Level9 > 0 THEN

PriceLevel9 = LastAth * (1 - Level9 / 100)

ENDIF

// ---------- Taille "théorique" à détenir selon la baisse vs ATH ----------

// Idée :

// - On compte combien de niveaux ont été atteints par le prix actuel (Close)

// - Pour chaque niveau atteint, on veut UnitsPerLevel en plus

// - On n'allège jamais sur rebond : la taille cible ne fait qu'augmenter

TargetSize = 0

IF PriceLevel1 > 0 AND Close <= PriceLevel1 THEN