forex-scalping.com

Code: Select all

// Run this check on the open of a new bar to save CPU cycles
bool IsSilverBulletWindow() {
    int currentHour = TimeHour(TimeCurrent());
    // Add broker offset logic here to align with EST windows
    if (currentHour >= StartHour && currentHour < EndHour) {
        return true;
    }
    return false;
}

Code: Select all

// Find the highest and lowest points over a defined lookback period
double BSL = High[iHighest(Symbol(), Period(), MODE_HIGH, LookbackBars, 1)];
double SSL = Low[iLowest(Symbol(), Period(), MODE_LOW, LookbackBars, 1)];

Code: Select all

// Bearish FVG Logic (Sellside Imbalance Buyside Inefficiency)
bool isBearishFVG = false;
double fvgTop = 0;
double fvgBottom = 0;

// If the high of the recent candle is lower than the low of the origin candle
if (High[1] < Low[3]) {
    isBearishFVG = true;
    fvgTop = Low[3];
    fvgBottom = High[1];
}

// Bullish FVG Logic (Buyside Imbalance Sellside Inefficiency)
bool isBullishFVG = false;

// If the low of the recent candle is higher than the high of the origin candle
if (Low[1] > High[3]) {
    isBullishFVG = true;
    fvgTop = High[3];
    fvgBottom = Low[1];
}

Code: Select all

//+------------------------------------------------------------------+
//| Calculates dynamic lot size based on account risk percentage     |
//+------------------------------------------------------------------+
double CalculateLotSize(double entryPrice, double stopLossPrice, double riskPercent) {
    // 1. Calculate maximum risk in the account's base currency
    double accountBalance = AccountBalance(); // Use AccountEquity() for stricter risk management
    double riskAmount = accountBalance * (riskPercent / 100.0);

    // 2. Calculate Stop Loss distance in points
    double slDistancePoints = MathAbs(entryPrice - stopLossPrice) / Point;
    
    // Safety check to prevent division by zero (e.g., if FVG logic failed)
    if (slDistancePoints == 0) {
        Print("Error: SL distance is zero.");
        return 0;
    }

    // 3. Calculate the monetary value of a single point per 1 standard lot
    double tickValue = MarketInfo(Symbol(), MODE_TICKVALUE);
    double tickSize  = MarketInfo(Symbol(), MODE_TICKSIZE);
    
    // Critical fix: Standardizes value for metals where Point != TickSize
    double pointValue = tickValue * (Point / tickSize); 

    // 4. Calculate raw lot size
    double riskPerLot = slDistancePoints * pointValue;
    double rawLotSize = riskAmount / riskPerLot;

    // 5. Normalize against broker lot constraints
    double minLot  = MarketInfo(Symbol(), MODE_MINLOT);
    double maxLot  = MarketInfo(Symbol(), MODE_MAXLOT);
    double lotStep = MarketInfo(Symbol(), MODE_LOTSTEP);

    // Round mathematically to the broker's required lot step
    int steps = (int)MathFloor(rawLotSize / lotStep); 
    double finalLotSize = steps * lotStep;

    // Clamp the final size to min/max boundaries
    if (finalLotSize < minLot) finalLotSize = minLot;
    if (finalLotSize > maxLot) finalLotSize = maxLot;

    return finalLotSize;
}

Code: Select all

// Example implementation in the execution phase
double myRisk = 1.0; // 1% account risk
double calcLot = CalculateLotSize(EntryPrice, StopLoss, myRisk);

if (calcLot > 0) {
    int ticket = OrderSend(Symbol(), OP_BUYLIMIT, calcLot, EntryPrice, 3, StopLoss, TakeProfit, "Silver Bullet Buy", MagicNumber, 0, Blue);
}

Code: Select all

//+------------------------------------------------------------------+
//| Checks if current market conditions are safe for execution       |
//+------------------------------------------------------------------+
bool IsExecutionSafe(int maxSpreadPoints) {
    // 1. Calculate the real-time spread accurately
    int currentSpread = (int)MathRound((Ask - Bid) / Point);
    
    // 2. Block execution if spread exceeds the threshold
    if (currentSpread > maxSpreadPoints) {
        Print("Execution Blocked: Spread widened to ", currentSpread, " points. Max allowed: ", maxSpreadPoints);
        return false;
    }
    
    // 3. Prevent execution if pricing feed is frozen/invalid
    if (Ask == 0 || Bid == 0) {
        Print("Execution Blocked: Invalid price feed.");
        return false;
    }
    
    return true;
}

Code: Select all

//+------------------------------------------------------------------+
//| Adjusts slippage points for 3/5 digit fractional brokers         |
//+------------------------------------------------------------------+
int NormalizeSlippage(int rawSlippagePips) {
    int adjustedSlippage = rawSlippagePips;
    
    // If the broker uses 3 or 5 digits (fractional pricing)
    if (Digits == 3 || Digits == 5) {
        adjustedSlippage = rawSlippagePips * 10;
    }
    
    return adjustedSlippage;
}

Code: Select all

// External parameters for user optimization
extern int MaxSpreadPoints = 40;  // e.g., 40 points (4.0 pips) max spread for Silver
extern int MaxSlippagePips = 2;   // 2 pips max slippage

// ... Inside your main execution logic (State 2) ...

if (IsExecutionSafe(MaxSpreadPoints)) {
    
    // Calculate dynamic lot size (from previous implementation)
    double calcLot = CalculateLotSize(EntryPrice, StopLoss, AccountRiskPercent);
    
    if (calcLot > 0) {
        // Normalize the slippage for the OrderSend command
        int safeSlippage = NormalizeSlippage(MaxSlippagePips);
        
        // Attempt execution
        int ticket = OrderSend(
            Symbol(), 
            OP_BUYLIMIT,      // Pending limit order at FVG
            calcLot, 
            EntryPrice, 
            safeSlippage,     // Digit-adjusted slippage
            StopLoss, 
            TakeProfit, 
            "Silver Bullet Entry", 
            MagicNumber, 
            0, 
            Blue
        );
        
        if (ticket < 0) {
            Print("Order placement failed. Error: ", GetLastError());
        }
    }
} else {
    // Optional: Reset state machine or wait for next tick if spread is too high
    Print("Waiting for spread to compress before placing limit order.");
}

Code: Select all

// External parameters for user optimization
extern double RR_Target = 1.0;        // Risk:Reward ratio to trigger the event (e.g., 1.0 = 1R)
extern double PartialClosePercent = 50.0; // Percentage of the position to close (e.g., 50%)
extern int    BreakevenOffsetPips = 1;    // Pips to lock in to cover commissions/swap

//+------------------------------------------------------------------+
//| Moves SL to Breakeven and takes partial profit at an RR target   |
//+------------------------------------------------------------------+
void ManageTrades() {
    // Loop backwards to safely handle index shifts during OrderClose
    for (int i = OrdersTotal() - 1; i >= 0; i--) {
        if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) {
            
            // Filter for our EA's trades on the current chart
            if (OrderSymbol() == Symbol() && OrderMagicNumber() == MagicNumber) {
                
                int type = OrderType();
                double openPrice = OrderOpenPrice();
                double currentSL = OrderStopLoss();
                
                // Calculate offset in points (using previous fractional digit logic)
                double offsetPoints = BreakevenOffsetPips * 10 * Point; // Assuming 3/5 digit broker
                double bePrice = (type == OP_BUY) ? openPrice + offsetPoints : openPrice - offsetPoints;
                
                // 1. STATE CHECK: If SL is already at or past BE, skip to prevent infinite loops
                if ((type == OP_BUY && currentSL >= bePrice) || 
                    (type == OP_SELL && (currentSL <= bePrice && currentSL != 0))) {
                    continue; 
                }
                
                // 2. Calculate the original risk distance to find the exact RR target
                double riskDistance = MathAbs(openPrice - currentSL);
                if (riskDistance == 0) continue; // Safety check
                
                bool targetHit = false;
                
                if (type == OP_BUY) {
                    double targetPrice = openPrice + (riskDistance * RR_Target);
                    if (Bid >= targetPrice) targetHit = true;
                } 
                else if (type == OP_SELL) {
                    double targetPrice = openPrice - (riskDistance * RR_Target);
                    if (Ask <= targetPrice) targetHit = true;
                }
                
                // 3. EXECUTION: Target Reached
                if (targetHit) {
                    
                    // STEP A: Move Stop Loss to Breakeven FIRST
                    // The new child ticket will inherit this modification
                    bool slMoved = OrderModify(OrderTicket(), openPrice, bePrice, OrderTakeProfit(), 0, Blue);
                    
                    // STEP B: Execute Partial Close
                    if (slMoved) {
                        double lotStep = MarketInfo(Symbol(), MODE_LOTSTEP);
                        double minLot = MarketInfo(Symbol(), MODE_MINLOT);
                        
                        // Calculate exact lots to close, rounded down to broker's lot step
                        double rawLots = OrderLots() * (PartialClosePercent / 100.0);
                        double lotsToClose = MathFloor(rawLots / lotStep) * lotStep;
                        
                        // Ensure we don't try to close less than the minimum allowed, or the full position
                        if (lotsToClose >= minLot && lotsToClose < OrderLots()) {
                            double closePrice = (type == OP_BUY) ? Bid : Ask;
                            int safeSlippage = NormalizeSlippage(2); // From previous slippage control
                            
                            bool closed = OrderClose(OrderTicket(), lotsToClose, closePrice, safeSlippage, clrGreen);
                            
                            if (!closed) {
                                Print("Partial close failed. Error: ", GetLastError());
                            }
                        }
                    } else {
                        Print("Failed to move SL to Breakeven. Error: ", GetLastError());
                    }
                }
            }
        }
    }
}