427 lines
20 KiB
Plaintext
427 lines
20 KiB
Plaintext
//+------------------------------------------------------------------+
|
|
//| ScoringTrade.mq5 |
|
|
//| Generated by ChatGPT |
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
#property strict
|
|
#include <Trade\Trade.mqh>
|
|
|
|
// Input parameters
|
|
input int MagicNumber = 42; // Unique identifier for this EA's trades
|
|
input int scoreThreshold = 15000; // Minimum score required to enter a trade (increased for BTC's larger price movements)
|
|
input int slopeThreshold = 3500; // Minimum EMA slope value to consider trend significant (increased for BTC's steeper trends)
|
|
input double maxScore = 25000; // Maximum allowed score before clamping (prevents excessive trade signals)
|
|
input int cooldownMinutes = 18; // Minimum time between crossover signals (prevents over-trading)
|
|
input int tradeCooldownMinutes = 44; // Minimum time between consecutive trades (trade debounce period)
|
|
input ENUM_TIMEFRAMES emaTimeFrame = PERIOD_H1; // Timeframe for EMA calculation (1-hour candles)
|
|
input double delayClampAbsolute = 5000; // Score threshold for applying decay (prevents score from growing too large)
|
|
input int emaPeriod = 139; // Number of periods for EMA calculation (longer period for smoother trend)
|
|
input double crossOverStep = 2500; // Score adjustment when price crosses EMA (increased for BTC's larger moves)
|
|
input double slopeThresholdStep = 2000; // Score adjustment for significant slope changes (increased for BTC)
|
|
input double emaDistanceStep = 500; // Score adjustment for price distance from EMA (increased for BTC)
|
|
input double emaDecayStep = 0; // Score decay rate when no significant signals (0 means no decay)
|
|
input double decayMultiplier = 0.08; // Multiplier applied to score when above delayClampAbsolute
|
|
input double distanceThreshold = 7100; // Minimum price-EMA distance to trigger score adjustment (increased for BTC)
|
|
input double atrMultiplier = 3.9; // Multiplier for dynamic stop loss calculation based on ATR
|
|
input double TrailingStop = 10; // Distance in points for trailing stop loss
|
|
input bool ApplyTrailingStop = true; // Enable/disable trailing stop functionality
|
|
input int maxCrossoverTrades = 14; // Maximum number of trades allowed per crossover signal
|
|
input double max_drawdown = 0.1; // Maximum allowed drawdown as percentage of account balance
|
|
input bool resetCrossoverTradeOnDistance = false; // Reset trade count when price moves beyond distance threshold
|
|
input int resetCrossoverNumber = 0; // Number of trades to reset to when resetCrossoverTradeOnDistance is true
|
|
input double minimumLotSize = 0.01; // Minimum trade size allowed
|
|
input int maxTimeInPosition = 1; // Maximum time in hours to hold a position
|
|
input int tradeLengthThreshold = 31; // Time in minutes before considering a reverse trade
|
|
input int reverseTP = 707; // Take profit level for reverse trades (increased for BTC)
|
|
input int reverseLotSizeMultiplier = 4; // Multiplier for lot size in reverse trades
|
|
input int secondaryPositionHoldTime = 75; // Maximum time in minutes to hold a secondary position
|
|
// Global variables
|
|
int emaHandle; // EMA handle
|
|
double prevScore = 0; // Previous score
|
|
double currentScore = 0; // Current score
|
|
double emaPrevValue = 0; // Previous EMA value
|
|
double emaCurrentValue = 0; // Current EMA value
|
|
double emaSlope = 0; // EMA slope value
|
|
CTrade trade; // Trading object
|
|
|
|
datetime lastCrossoverTime = 0; // Time of last crossover
|
|
datetime lastTradeTime = 0; // Time of last trade
|
|
int crossoverTradeCount = 0; // Count of trades after each crossover
|
|
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Expert initialization function |
|
|
//+------------------------------------------------------------------+
|
|
int OnInit() {
|
|
// Create EMA handle (e.g., 14-period EMA on the closing price)
|
|
emaHandle = iMA(Symbol(), emaTimeFrame, emaPeriod, 0, MODE_EMA, PRICE_CLOSE);
|
|
|
|
if (emaHandle == INVALID_HANDLE) {
|
|
Print("Failed to create EMA handle");
|
|
return INIT_FAILED;
|
|
}
|
|
|
|
return INIT_SUCCEEDED;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Expert deinitialization function |
|
|
//+------------------------------------------------------------------+
|
|
void OnDeinit(const int reason) {
|
|
// Release the EMA handle
|
|
if (emaHandle != INVALID_HANDLE) {
|
|
ExpertRemove();
|
|
}
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Expert tick function |
|
|
//+------------------------------------------------------------------+
|
|
void OnTick() {
|
|
// Buffer to hold the EMA values
|
|
double emaBuffer[];
|
|
|
|
// Get dynamic lot size based on current balance and max drawdown
|
|
double lotSize = CalculateLotSize();
|
|
|
|
if(lotSize < minimumLotSize) {
|
|
lotSize = minimumLotSize;
|
|
}
|
|
|
|
// Get the current Ask and Bid prices
|
|
double Ask = SymbolInfoDouble(Symbol(), SYMBOL_ASK);
|
|
double Bid = SymbolInfoDouble(Symbol(), SYMBOL_BID);
|
|
|
|
// Copy the last 2 EMA values (current and previous)
|
|
int copied = CopyBuffer(emaHandle, 0, 0, 2, emaBuffer);
|
|
if (copied < 2) {
|
|
return;
|
|
}
|
|
|
|
// Get the current and previous EMA values
|
|
emaPrevValue = emaBuffer[1]; // Previous EMA value (index 1)
|
|
emaCurrentValue = emaBuffer[0]; // Current EMA value (index 0)
|
|
|
|
// Calculate the EMA slope (change in EMA values)
|
|
emaSlope = - (emaCurrentValue - emaPrevValue) * 100;
|
|
Print("EMA Slope: ", emaSlope);
|
|
|
|
// Check for price action crossover with EMA
|
|
double closePrev = iClose(Symbol(), Period(), 1); // Close of previous bar
|
|
double closeCurr = iClose(Symbol(), Period(), 0); // Close of current bar
|
|
|
|
// Check if enough time has passed for the cooldown (cooldownMinutes)
|
|
if (TimeCurrent() - lastCrossoverTime >= cooldownMinutes * 60) {
|
|
if (closePrev < emaPrevValue && closeCurr > emaCurrentValue) { // Bullish crossover
|
|
currentScore += crossOverStep;
|
|
crossoverTradeCount = 0; // Reset trade count after new crossover
|
|
lastCrossoverTime = TimeCurrent(); // Update the last crossover time
|
|
}
|
|
else if (closePrev > emaPrevValue && closeCurr < emaCurrentValue) { // Bearish crossover
|
|
currentScore -= crossOverStep;
|
|
crossoverTradeCount = 0; // Reset trade count after new crossover
|
|
lastCrossoverTime = TimeCurrent(); // Update the last crossover time
|
|
}
|
|
}
|
|
|
|
// Check EMA slope
|
|
if (emaSlope > slopeThreshold) { // Positive slope
|
|
currentScore += slopeThresholdStep;
|
|
}
|
|
else if (emaSlope < -slopeThreshold) { // Negative slope
|
|
currentScore -= slopeThresholdStep;
|
|
}
|
|
else {
|
|
if (MathAbs(currentScore) > delayClampAbsolute) {
|
|
currentScore *= decayMultiplier;
|
|
}
|
|
}
|
|
|
|
if(ApplyTrailingStop) {
|
|
ApplyTrailingStop();
|
|
}
|
|
|
|
// Calculate distance to EMA and adjust score
|
|
double priceToEmaDistance = closeCurr - emaCurrentValue; // Distance between the current price and the EMA
|
|
Print("Price to EMA Distance: ", priceToEmaDistance);
|
|
|
|
if (MathAbs(priceToEmaDistance) > distanceThreshold) {
|
|
if (priceToEmaDistance > 0) { // Bullish (price above EMA)
|
|
currentScore += emaDistanceStep;
|
|
}
|
|
else if (priceToEmaDistance < 0) { // Bearish (price below EMA)
|
|
currentScore -= emaDistanceStep;
|
|
}
|
|
}
|
|
else {
|
|
if (currentScore > 0) {
|
|
currentScore -= emaDecayStep;
|
|
}
|
|
else {
|
|
currentScore += emaDecayStep;
|
|
}
|
|
}
|
|
|
|
// Close all positions if score crosses zero
|
|
if ((prevScore > 0 && currentScore <= 0) || (prevScore < 0 && currentScore >= 0)) {
|
|
Close_Position_MN(MagicNumber);
|
|
}
|
|
|
|
// Update the previous score
|
|
prevScore = currentScore;
|
|
|
|
if (crossoverTradeCount > maxCrossoverTrades) {
|
|
return;
|
|
}
|
|
|
|
// Debounce check: Ensure enough time has passed since the last trade
|
|
if (TimeCurrent() - lastTradeTime >= tradeCooldownMinutes * 60) {
|
|
// Calculate ATR (Average True Range) for stop loss calculation
|
|
double atrArray[];
|
|
int atrPeriod = 14; // ATR period (can be adjusted)
|
|
int copied = CopyBuffer(iATR(Symbol(), Period(), atrPeriod), 0, 0, 1, atrArray);
|
|
if (copied < 1) {
|
|
return;
|
|
}
|
|
|
|
// Get the current price (using Bid price)
|
|
double currentPrice = Bid;
|
|
// Get ATR value
|
|
double atrValue = atrArray[0]; // Latest ATR value
|
|
|
|
// Get the minimum stop level and freeze level for the symbol
|
|
int stopLevel = SymbolInfoInteger(Symbol(), SYMBOL_TRADE_STOPS_LEVEL);
|
|
int freezeLevel = SymbolInfoInteger(Symbol(), SYMBOL_TRADE_FREEZE_LEVEL);
|
|
|
|
// Calculate the minimum stop loss in price units (converted from pips)
|
|
double minStopLoss = stopLevel * SymbolInfoDouble(Symbol(), SYMBOL_POINT);
|
|
double minFreezeLevel = freezeLevel * SymbolInfoDouble(Symbol(), SYMBOL_POINT);
|
|
|
|
// Dynamic Stop Loss and Take Profit calculation based on ATR
|
|
double dynamicSL = atrValue * atrMultiplier;
|
|
double dynamicTP = atrValue * atrMultiplier;
|
|
|
|
// Adjust SL and TP if they are smaller than the minimum stop level
|
|
dynamicSL = MathMax(dynamicSL, minStopLoss);
|
|
dynamicTP = MathMax(dynamicTP, dynamicSL); // Ensure TP is at least the same as SL
|
|
|
|
// Trade logic based on the score
|
|
if (currentScore > scoreThreshold) { // Buy signal
|
|
if (PositionSelect(Symbol()) == false || !PositionGetInteger(POSITION_MAGIC) == MagicNumber && crossoverTradeCount < maxCrossoverTrades) {
|
|
// Open buy position with dynamic SL and TP
|
|
trade.SetExpertMagicNumber(MagicNumber);
|
|
if (trade.Buy(lotSize, Symbol(), currentPrice, Bid - dynamicSL, 0)) {
|
|
crossoverTradeCount++; // Increment trade count
|
|
lastTradeTime = TimeCurrent(); // Update the last trade time
|
|
}
|
|
}
|
|
}
|
|
else if (currentScore < -scoreThreshold) { // Sell signal
|
|
if (PositionSelect(Symbol()) == false || !PositionGetInteger(POSITION_MAGIC) == MagicNumber && crossoverTradeCount < maxCrossoverTrades) {
|
|
// Open sell position with dynamic SL and TP
|
|
trade.SetExpertMagicNumber(MagicNumber);
|
|
if (trade.Sell(lotSize, Symbol(), currentPrice, Ask + dynamicSL, 0)) {
|
|
crossoverTradeCount++; // Increment trade count
|
|
lastTradeTime = TimeCurrent(); // Update the last trade time
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Check existing positions for profit and place reverse trade if needed
|
|
CheckPositions();
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Check existing positions for profit and place reverse trade if needed |
|
|
//+------------------------------------------------------------------+
|
|
void CheckPositions() {
|
|
// Check if there are any open positions
|
|
if (PositionsTotal() > 0) {
|
|
// Check if there are exactly 2 open positions
|
|
if (PositionsTotal() == 2) {
|
|
for (int i = 0; i < PositionsTotal(); i++) {
|
|
ulong ticket = PositionGetTicket(i);
|
|
if (PositionSelectByTicket(ticket)) {
|
|
datetime openTime = PositionGetInteger(POSITION_TIME);
|
|
int tradeLength = TimeCurrent() - openTime; // Trade duration in seconds
|
|
|
|
// Check if the trade has been open for more than the secondaryPositionHoldTime
|
|
if (tradeLength > secondaryPositionHoldTime * 60) { // Convert threshold to seconds
|
|
// Close all positions
|
|
CloseAllPositions();
|
|
return; // Exit the function after closing all positions
|
|
}
|
|
}
|
|
}
|
|
} else if (PositionsTotal() < 2) {
|
|
for (int i = 0; i < PositionsTotal(); i++) {
|
|
ulong ticket = PositionGetTicket(i);
|
|
if (PositionSelectByTicket(ticket)) {
|
|
double profit = PositionGetDouble(POSITION_PROFIT);
|
|
datetime openTime = PositionGetInteger(POSITION_TIME);
|
|
int tradeLength = TimeCurrent() - openTime; // Trade duration in seconds
|
|
|
|
// Check if the trade has been open for more than the tradeLengthThreshold
|
|
if (tradeLength > tradeLengthThreshold * 60) { // Convert threshold to seconds
|
|
double lotSize = PositionGetDouble(POSITION_VOLUME);
|
|
double newLotSize = lotSize * reverseLotSizeMultiplier; // 10 times the original lot size
|
|
|
|
crossoverTradeCount = maxCrossoverTrades + 1;
|
|
|
|
// Place a reverse trade
|
|
if (PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY) {
|
|
trade.SetExpertMagicNumber(MagicNumber);
|
|
if (trade.Sell(newLotSize, Symbol(), SymbolInfoDouble(Symbol(), SYMBOL_BID))) {
|
|
} else {
|
|
Print("Failed to execute reversal sell order");
|
|
}
|
|
} else if (PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_SELL) {
|
|
trade.SetExpertMagicNumber(MagicNumber);
|
|
if (trade.Buy(newLotSize, Symbol(), SymbolInfoDouble(Symbol(), SYMBOL_ASK))) {
|
|
} else {
|
|
Print("Failed to execute reversal buy order");
|
|
}
|
|
}
|
|
}
|
|
|
|
// Close the trade if profit meets the take profit level
|
|
if (profit >= reverseTP) {
|
|
Close_Position_MN(MagicNumber);
|
|
CloseAllPositions();
|
|
}
|
|
|
|
// Check if there is only one position and its volume is lotSize * reverseLotSizeMultiplier
|
|
if (PositionsTotal() == 1 && PositionGetDouble(POSITION_VOLUME) == minimumLotSize * reverseLotSizeMultiplier) {
|
|
trade.PositionClose(ticket);
|
|
}
|
|
|
|
// Get the current Ask and Bid prices
|
|
double Ask = SymbolInfoDouble(Symbol(), SYMBOL_ASK);
|
|
double Bid = SymbolInfoDouble(Symbol(), SYMBOL_BID);
|
|
|
|
// Check if the double down trade is exited by stop loss
|
|
if (PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY && PositionGetDouble(POSITION_SL) > 0 && Bid <= PositionGetDouble(POSITION_SL)) {
|
|
// Close the original trade
|
|
CloseOriginalTrade();
|
|
} else if (PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_SELL && PositionGetDouble(POSITION_SL) > 0 && Ask >= PositionGetDouble(POSITION_SL)) {
|
|
// Close the original trade
|
|
CloseOriginalTrade();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Function to close the original trade
|
|
void CloseOriginalTrade() {
|
|
for (int i = PositionsTotal() - 1; i >= 0; i--) {
|
|
ulong ticket = PositionGetTicket(i);
|
|
if (PositionSelectByTicket(ticket)) {
|
|
if (PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY) {
|
|
trade.PositionClose(ticket);
|
|
} else if (PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_SELL) {
|
|
trade.PositionClose(ticket);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Function to close all positions |
|
|
//+------------------------------------------------------------------+
|
|
void CloseAllPositions() {
|
|
// Loop through all positions and close them
|
|
for (int i = PositionsTotal() - 1; i >= 0; i--) {
|
|
ulong ticket = PositionGetTicket(i);
|
|
if (PositionSelectByTicket(ticket)) {
|
|
if (PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY) {
|
|
trade.PositionClose(ticket);
|
|
}
|
|
else if (PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_SELL) {
|
|
trade.PositionClose(ticket);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void ApplyTrailingStop()
|
|
{
|
|
for(int i=PositionsTotal()-1; i>=0; i--)
|
|
{
|
|
string symbol = PositionGetSymbol(i);
|
|
ulong PositionTicket = PositionGetTicket(i);
|
|
long trade_type = PositionGetInteger(POSITION_TYPE);
|
|
|
|
if(!PositionGetInteger(POSITION_MAGIC) == MagicNumber) {
|
|
return;
|
|
}
|
|
|
|
double POINT = SymbolInfoDouble( symbol, SYMBOL_POINT );
|
|
int DIGIT = (int) SymbolInfoInteger( symbol, SYMBOL_DIGITS );
|
|
|
|
if(trade_type == 0)
|
|
{
|
|
double Bid = NormalizeDouble(SymbolInfoDouble(symbol,SYMBOL_BID),DIGIT);
|
|
|
|
if(Bid-PositionGetDouble(POSITION_PRICE_OPEN) > NormalizeDouble(POINT * TrailingStop,DIGIT))
|
|
{
|
|
if(PositionGetDouble(POSITION_SL) < NormalizeDouble(Bid - POINT * TrailingStop,DIGIT))
|
|
{
|
|
trade.PositionModify(PositionTicket,NormalizeDouble(Bid - POINT * TrailingStop,DIGIT),PositionGetDouble(POSITION_TP));
|
|
}
|
|
}
|
|
}
|
|
|
|
if(trade_type == 1)
|
|
{
|
|
double Ask = NormalizeDouble(SymbolInfoDouble(symbol,SYMBOL_ASK),DIGIT);
|
|
|
|
if((PositionGetDouble(POSITION_PRICE_OPEN) - Ask) > NormalizeDouble( POINT * TrailingStop,DIGIT))
|
|
{
|
|
if((PositionGetDouble(POSITION_SL) > NormalizeDouble(Ask + POINT * TrailingStop,DIGIT)) || (PositionGetDouble(POSITION_SL)==0))
|
|
{
|
|
trade.PositionModify(PositionTicket,NormalizeDouble(Ask + POINT * TrailingStop,DIGIT),PositionGetDouble(POSITION_TP));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void Close_Position_MN(ulong magicNumber)
|
|
{
|
|
int total = PositionsTotal();
|
|
for(int i = total - 1; i >= 0; i--)
|
|
{
|
|
ulong ticket = PositionGetTicket(i);
|
|
|
|
// Use PositionSelect by symbol instead of ticket
|
|
string symbol = PositionGetSymbol(i);
|
|
if(PositionSelect(symbol))
|
|
{
|
|
if (PositionGetInteger(POSITION_MAGIC) == magicNumber && PositionGetInteger(POSITION_TICKET) == ticket)
|
|
{
|
|
if(symbol == _Symbol) // Verify the symbol
|
|
{
|
|
trade.PositionClose(ticket);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Calculate the dynamic lot size based on max drawdown |
|
|
//+------------------------------------------------------------------+
|
|
double CalculateLotSize()
|
|
{
|
|
double balance = AccountInfoDouble(ACCOUNT_BALANCE); // Get account balance
|
|
double allowedDrawdown = balance * max_drawdown; // Calculate allowed drawdown in account currency
|
|
double baseDrawdownPerLot = 150; // Assumed drawdown per 0.01 lots as per backtest
|
|
|
|
// Calculate lot size based on maximum drawdown
|
|
double lotSize = (allowedDrawdown / baseDrawdownPerLot) * 0.01;
|
|
return NormalizeDouble(lotSize, 2); // Normalize lot size to 2 decimal places
|
|
}
|