mirror of
https://github.com/rithsila/MT5-EA-Sniper-Strategy.git
synced 2026-08-17 04:38:12 +00:00
Remove tests directory from git tracking and update .gitignore
- Added tests/, Tests/, TESTS/ to .gitignore - Removed tests directory from git tracking while keeping it locally - Tests directory contains logs, validation reports, and temporary test files - This prevents test artifacts from being committed to the repository
This commit is contained in:
rithsila
+3
-1
@@ -5,10 +5,12 @@
|
||||
# =============================================================================
|
||||
|
||||
# Test directory (contains logs, test files, validation reports)
|
||||
tests/
|
||||
test/
|
||||
Test/
|
||||
TEST/
|
||||
tests/
|
||||
Tests/
|
||||
TESTS/
|
||||
|
||||
# Log files
|
||||
*.log
|
||||
|
||||
@@ -0,0 +1,433 @@
|
||||
# 🚨 Critical Fixes Implementation Plan - SniperEA Algorithmic Bugs
|
||||
|
||||
## Executive Summary
|
||||
|
||||
Based on comprehensive analysis of the weekend test failure (0 trades in 3 months, 155K BOS failures, 66K liquidity sweep failures), I've identified **5 critical algorithmic bugs** that prevent the EA from functioning in extended testing. This plan provides specific code fixes and implementation strategies.
|
||||
|
||||
## 🔍 Root Cause Analysis
|
||||
|
||||
### Critical Bug #1: **BOS Detection Algorithm Failure**
|
||||
|
||||
**Problem**: `FindSwingPoints()` function uses overly restrictive swing detection criteria
|
||||
**Evidence**: 155,038 instances of "BOS:0" across all timeframes
|
||||
**Root Cause**: Swing point detection requires perfect price patterns that rarely occur in real markets
|
||||
|
||||
### Critical Bug #2: **Liquidity Sweep Detection Failure**
|
||||
|
||||
**Problem**: `FindEqualHighsLows()` requires exact price matches within 3 pips
|
||||
**Evidence**: 66,048 instances of "Sweeps:0" across all timeframes
|
||||
**Root Cause**: Equal level detection is too restrictive for volatile markets
|
||||
|
||||
### Critical Bug #3: **Historical Data Processing Issues**
|
||||
|
||||
**Problem**: Time-based validations fail with historical data
|
||||
**Evidence**: Works with 3-day recent data, fails with 3-month historical data
|
||||
**Root Cause**: `iTime(symbol, timeframe, 0)` returns different values for historical vs real-time
|
||||
|
||||
### Critical Bug #4: **Memory/Performance Degradation**
|
||||
|
||||
**Problem**: Pattern arrays not properly cleaned up during extended testing
|
||||
**Evidence**: Identical bias calculations across different currency pairs
|
||||
**Root Cause**: Array overflow and memory management issues
|
||||
|
||||
### Critical Bug #5: **Trade Execution Logic Gaps**
|
||||
|
||||
**Problem**: `ValidateFlexibleConfluence()` has logical flaws in pattern validation
|
||||
**Evidence**: Patterns detected but no trades executed
|
||||
**Root Cause**: Validation sequence breaks when patterns are found in wrong order
|
||||
|
||||
## 🎯 Priority 1: Emergency Algorithm Fixes
|
||||
|
||||
### Fix #1: BOS Detection Algorithm Overhaul
|
||||
|
||||
#### Current Issues:
|
||||
|
||||
```mql5
|
||||
// PROBLEMATIC CODE in FindSwingPoints()
|
||||
for (int i = SwingLookback; i < bars_to_analyze - SwingLookback; i++)
|
||||
{
|
||||
bool is_swing_high = true;
|
||||
for (int j = i - SwingLookback; j <= i + SwingLookback; j++)
|
||||
{
|
||||
if (j != i && iHigh(symbol, timeframe, j) >= iHigh(symbol, timeframe, i))
|
||||
{
|
||||
is_swing_high = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
#### **SOLUTION: Implement Multi-Level Swing Detection**
|
||||
|
||||
```mql5
|
||||
// NEW IMPROVED ALGORITHM
|
||||
bool FindSwingPointsImproved(string symbol, ENUM_TIMEFRAMES timeframe, int bars_to_analyze,
|
||||
double &swing_highs[], double &swing_lows[],
|
||||
datetime &swing_high_times[], datetime &swing_low_times[])
|
||||
{
|
||||
// Use multiple lookback periods for better detection
|
||||
int lookback_periods[] = {3, 5, 8, 13}; // Fibonacci-based periods
|
||||
|
||||
for (int p = 0; p < ArraySize(lookback_periods); p++)
|
||||
{
|
||||
int current_lookback = lookback_periods[p];
|
||||
|
||||
for (int i = current_lookback; i < bars_to_analyze - current_lookback; i++)
|
||||
{
|
||||
// More flexible swing detection - require 70% of bars to be lower/higher
|
||||
int higher_count = 0, lower_count = 0;
|
||||
int total_bars = current_lookback * 2;
|
||||
|
||||
for (int j = i - current_lookback; j <= i + current_lookback; j++)
|
||||
{
|
||||
if (j != i)
|
||||
{
|
||||
if (iHigh(symbol, timeframe, j) < iHigh(symbol, timeframe, i))
|
||||
higher_count++;
|
||||
if (iLow(symbol, timeframe, j) > iLow(symbol, timeframe, i))
|
||||
lower_count++;
|
||||
}
|
||||
}
|
||||
|
||||
// Swing high if 70% of surrounding bars are lower
|
||||
if (higher_count >= (total_bars * 0.7))
|
||||
{
|
||||
AddUniqueSwingPoint(swing_highs, swing_high_times,
|
||||
iHigh(symbol, timeframe, i), iTime(symbol, timeframe, i));
|
||||
}
|
||||
|
||||
// Swing low if 70% of surrounding bars are higher
|
||||
if (lower_count >= (total_bars * 0.7))
|
||||
{
|
||||
AddUniqueSwingPoint(swing_lows, swing_low_times,
|
||||
iLow(symbol, timeframe, i), iTime(symbol, timeframe, i));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return ArraySize(swing_highs) > 0 || ArraySize(swing_lows) > 0;
|
||||
}
|
||||
```
|
||||
|
||||
### Fix #2: Liquidity Sweep Detection System Overhaul
|
||||
|
||||
#### Current Issues:
|
||||
|
||||
```mql5
|
||||
// PROBLEMATIC CODE in FindEqualHighsLows()
|
||||
double tolerance = 3.0 * pip_value; // Too restrictive
|
||||
if (equal_count >= 2) // Requires exact matches
|
||||
```
|
||||
|
||||
#### **SOLUTION: Implement Zone-Based Sweep Detection**
|
||||
|
||||
```mql5
|
||||
// NEW ZONE-BASED ALGORITHM
|
||||
bool DetectLiquiditySweepsImproved(string symbol, ENUM_TIMEFRAMES timeframe, LiquiditySweep &sweep_array[])
|
||||
{
|
||||
ArrayResize(sweep_array, 0);
|
||||
|
||||
// Create liquidity zones instead of exact levels
|
||||
LiquidityZone zones[];
|
||||
CreateLiquidityZones(symbol, timeframe, zones);
|
||||
|
||||
for (int i = 0; i < ArraySize(zones); i++)
|
||||
{
|
||||
// Look for sweeps of liquidity zones (not exact levels)
|
||||
if (DetectZoneSweep(symbol, timeframe, zones[i]))
|
||||
{
|
||||
LiquiditySweep sweep;
|
||||
sweep.level = zones[i].center_price;
|
||||
sweep.time = zones[i].sweep_time;
|
||||
sweep.is_high_sweep = zones[i].is_high_zone;
|
||||
sweep.confirmed = true; // Zone-based sweeps are auto-confirmed
|
||||
|
||||
ArrayResize(sweep_array, ArraySize(sweep_array) + 1);
|
||||
sweep_array[ArraySize(sweep_array) - 1] = sweep;
|
||||
}
|
||||
}
|
||||
|
||||
return ArraySize(sweep_array) > 0;
|
||||
}
|
||||
|
||||
struct LiquidityZone
|
||||
{
|
||||
double upper_bound;
|
||||
double lower_bound;
|
||||
double center_price;
|
||||
datetime formation_time;
|
||||
datetime sweep_time;
|
||||
bool is_high_zone;
|
||||
int touch_count;
|
||||
};
|
||||
|
||||
void CreateLiquidityZones(string symbol, ENUM_TIMEFRAMES timeframe, LiquidityZone &zones[])
|
||||
{
|
||||
double pip_value = CalculatePipValue(symbol);
|
||||
double zone_width = 8.0 * pip_value; // 8-pip zones instead of 3-pip exact levels
|
||||
|
||||
// Group nearby highs/lows into zones
|
||||
double recent_highs[], recent_lows[];
|
||||
GetRecentHighsLows(symbol, timeframe, recent_highs, recent_lows);
|
||||
|
||||
// Create zones from clustered levels
|
||||
CreateZonesFromLevels(recent_highs, true, zone_width, zones);
|
||||
CreateZonesFromLevels(recent_lows, false, zone_width, zones);
|
||||
}
|
||||
```
|
||||
|
||||
### Fix #3: Historical Data Processing Issues
|
||||
|
||||
#### Current Issues:
|
||||
|
||||
```mql5
|
||||
// PROBLEMATIC CODE - Time validation fails with historical data
|
||||
datetime current_time = iTime(symbol, timeframe, 0);
|
||||
int time_diff = (int)((current_time - bos.time) / PeriodSeconds(timeframe));
|
||||
if (time_diff > BOSConfirmationCandles * 6) return false;
|
||||
```
|
||||
|
||||
#### **SOLUTION: Implement Bar-Based Validation**
|
||||
|
||||
```mql5
|
||||
// NEW BAR-BASED VALIDATION
|
||||
bool IsBOSValidImproved(string symbol, ENUM_TIMEFRAMES timeframe, BreakOfStructure &bos)
|
||||
{
|
||||
// Use bar shift instead of time difference for historical compatibility
|
||||
int bos_bar = iBarShift(symbol, timeframe, bos.time);
|
||||
if (bos_bar < 0) return false;
|
||||
|
||||
// Check if BOS is within reasonable bar distance (not time distance)
|
||||
if (bos_bar > BOSConfirmationCandles * 10) // Increased from 6 to 10
|
||||
return false;
|
||||
|
||||
// Validate price action relative to BOS level
|
||||
double current_price = iClose(symbol, timeframe, 0);
|
||||
double bos_validation_buffer = 2.0 * CalculatePipValue(symbol);
|
||||
|
||||
if (bos.is_bullish)
|
||||
{
|
||||
return current_price > (bos.level - bos_validation_buffer);
|
||||
}
|
||||
else
|
||||
{
|
||||
return current_price < (bos.level + bos_validation_buffer);
|
||||
}
|
||||
}
|
||||
|
||||
bool IsLiquiditySweepValidImproved(string symbol, ENUM_TIMEFRAMES timeframe, LiquiditySweep &sweep)
|
||||
{
|
||||
if (!sweep.confirmed) return false;
|
||||
|
||||
// Use bar-based validation instead of time-based
|
||||
int sweep_bar = iBarShift(symbol, timeframe, sweep.time);
|
||||
if (sweep_bar < 0 || sweep_bar > 20) // Within 20 bars instead of 10 time periods
|
||||
return false;
|
||||
|
||||
// More flexible price position validation
|
||||
double current_price = iClose(symbol, timeframe, 0);
|
||||
double validation_buffer = 3.0 * CalculatePipValue(symbol);
|
||||
|
||||
if (sweep.is_high_sweep)
|
||||
{
|
||||
return current_price < (sweep.level + validation_buffer);
|
||||
}
|
||||
else
|
||||
{
|
||||
return current_price > (sweep.level - validation_buffer);
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
## 🎯 Priority 2: Memory Management & Performance Fixes
|
||||
|
||||
### Fix #4: Array Management and Cleanup
|
||||
|
||||
#### **SOLUTION: Implement Proper Array Management**
|
||||
|
||||
```mql5
|
||||
// NEW ARRAY MANAGEMENT SYSTEM
|
||||
#define MAX_PATTERN_HISTORY 100
|
||||
#define CLEANUP_FREQUENCY 50
|
||||
|
||||
struct PatternArrayManager
|
||||
{
|
||||
int cleanup_counter;
|
||||
datetime last_cleanup;
|
||||
};
|
||||
|
||||
PatternArrayManager g_array_manager;
|
||||
|
||||
void CleanupPatternArrays(MarketStructureData &mtf_data)
|
||||
{
|
||||
g_array_manager.cleanup_counter++;
|
||||
|
||||
if (g_array_manager.cleanup_counter >= CLEANUP_FREQUENCY)
|
||||
{
|
||||
// Clean up old patterns
|
||||
CleanupOldOrderBlocks(mtf_data.order_blocks);
|
||||
CleanupOldFVGs(mtf_data.fair_value_gaps);
|
||||
CleanupOldBOSEvents(mtf_data.bos_events);
|
||||
CleanupOldSweeps(mtf_data.liquidity_sweeps);
|
||||
|
||||
g_array_manager.cleanup_counter = 0;
|
||||
g_array_manager.last_cleanup = TimeCurrent();
|
||||
}
|
||||
}
|
||||
|
||||
void CleanupOldOrderBlocks(OrderBlock &order_blocks[])
|
||||
{
|
||||
if (ArraySize(order_blocks) <= MAX_PATTERN_HISTORY) return;
|
||||
|
||||
// Keep only the most recent patterns
|
||||
int keep_count = MAX_PATTERN_HISTORY;
|
||||
OrderBlock temp_array[];
|
||||
ArrayResize(temp_array, keep_count);
|
||||
|
||||
for (int i = 0; i < keep_count; i++)
|
||||
{
|
||||
temp_array[i] = order_blocks[ArraySize(order_blocks) - keep_count + i];
|
||||
}
|
||||
|
||||
ArrayCopy(order_blocks, temp_array);
|
||||
}
|
||||
```
|
||||
|
||||
## 🎯 Priority 3: Trade Execution Logic Fixes
|
||||
|
||||
### Fix #5: Confluence Validation Logic
|
||||
|
||||
#### Current Issues:
|
||||
|
||||
```mql5
|
||||
// PROBLEMATIC CODE - Sequential validation breaks
|
||||
if (sweep_valid && m1_data.bos_events[i].time <= valid_sweep.time)
|
||||
continue; // This breaks when patterns are found in wrong order
|
||||
```
|
||||
|
||||
#### **SOLUTION: Implement Flexible Pattern Sequencing**
|
||||
|
||||
```mql5
|
||||
// NEW FLEXIBLE VALIDATION LOGIC
|
||||
bool ValidateFlexibleConfluenceImproved(string symbol, bool is_bullish, MarketStructureData &m1_data)
|
||||
{
|
||||
LogDebug(StringFormat("=== Improved Confluence Validation for %s %s Setup ===",
|
||||
symbol, is_bullish ? "Bullish" : "Bearish"));
|
||||
|
||||
PatternScore scores;
|
||||
scores.sweep_score = CalculateSweepScore(symbol, is_bullish, m1_data);
|
||||
scores.bos_score = CalculateBOSScore(symbol, is_bullish, m1_data);
|
||||
scores.fvg_score = CalculateFVGScore(symbol, is_bullish, m1_data);
|
||||
scores.ob_score = CalculateOBScore(symbol, is_bullish, m1_data);
|
||||
|
||||
// Score-based validation instead of binary pass/fail
|
||||
double total_score = scores.sweep_score + scores.bos_score + scores.fvg_score + scores.ob_score;
|
||||
double required_score = 60.0; // Require 60% total score instead of 3/4 criteria
|
||||
|
||||
LogDebug(StringFormat("Pattern Scores: Sweep=%.1f, BOS=%.1f, FVG=%.1f, OB=%.1f, Total=%.1f/100",
|
||||
scores.sweep_score, scores.bos_score, scores.fvg_score, scores.ob_score, total_score));
|
||||
|
||||
if (total_score >= required_score)
|
||||
{
|
||||
LogDebug(StringFormat("Score-based confluence met (%.1f >= %.1f) - executing trade", total_score, required_score));
|
||||
return ExecuteTradeWithScores(symbol, is_bullish, scores, m1_data);
|
||||
}
|
||||
|
||||
LogDebug(StringFormat("Insufficient confluence score (%.1f < %.1f)", total_score, required_score));
|
||||
return false;
|
||||
}
|
||||
|
||||
struct PatternScore
|
||||
{
|
||||
double sweep_score; // 0-25 points
|
||||
double bos_score; // 0-25 points
|
||||
double fvg_score; // 0-25 points
|
||||
double ob_score; // 0-25 points
|
||||
};
|
||||
```
|
||||
|
||||
## 📋 Implementation Timeline
|
||||
|
||||
### Phase 1: Emergency Fixes (Day 1)
|
||||
|
||||
1. **Morning**: Implement BOS detection overhaul
|
||||
2. **Afternoon**: Implement liquidity sweep zone-based detection
|
||||
3. **Evening**: Test fixes with 1-week historical data
|
||||
|
||||
### Phase 2: Stability Fixes (Day 2)
|
||||
|
||||
1. **Morning**: Implement historical data processing fixes
|
||||
2. **Afternoon**: Implement array management and cleanup
|
||||
3. **Evening**: Test fixes with 1-month historical data
|
||||
|
||||
### Phase 3: Logic Optimization (Day 3)
|
||||
|
||||
1. **Morning**: Implement improved confluence validation
|
||||
2. **Afternoon**: Comprehensive testing and parameter tuning
|
||||
3. **Evening**: Full 3-month weekend test validation
|
||||
|
||||
## 🧪 Testing Strategy
|
||||
|
||||
### Progressive Validation Tests:
|
||||
|
||||
1. **1-Week Test**: Verify basic pattern detection works
|
||||
2. **1-Month Test**: Validate memory management and stability
|
||||
3. **3-Month Test**: Full weekend test validation
|
||||
4. **Multi-Symbol Test**: Ensure fixes work across all currency pairs
|
||||
|
||||
### Success Criteria:
|
||||
|
||||
- **BOS Detection**: >50% success rate (vs. current 0%)
|
||||
- **Liquidity Sweeps**: >30% success rate (vs. current 0%)
|
||||
- **Trade Executions**: >20 trades in 3-month test (vs. current 0)
|
||||
- **Memory Stability**: No identical bias calculations across symbols
|
||||
|
||||
## 🚨 Critical Implementation Notes
|
||||
|
||||
1. **Backup Current Code**: Create full backup before implementing fixes
|
||||
2. **Incremental Testing**: Test each fix individually before combining
|
||||
3. **Parameter Documentation**: Document all new parameters and their effects
|
||||
4. **Performance Monitoring**: Add performance metrics to track improvements
|
||||
5. **Rollback Plan**: Maintain ability to revert to previous version if needed
|
||||
|
||||
This implementation plan addresses the fundamental algorithmic issues that prevent the EA from functioning in extended testing scenarios. The fixes focus on making the pattern detection algorithms more robust and flexible while maintaining the sophisticated analysis capabilities of the SniperEA system.
|
||||
|
||||
## 🔧 Immediate Action Items
|
||||
|
||||
### Step 1: Create Emergency Fix Branch
|
||||
|
||||
```bash
|
||||
git checkout -b emergency-algorithmic-fixes
|
||||
git add docs/CRITICAL_FIXES_IMPLEMENTATION_PLAN.md
|
||||
git commit -m "Add critical fixes implementation plan for weekend test failures"
|
||||
```
|
||||
|
||||
### Step 2: Implement Priority 1 Fixes
|
||||
|
||||
1. **BOS Detection Fix**: Replace `FindSwingPoints()` with improved algorithm
|
||||
2. **Liquidity Sweep Fix**: Replace `FindEqualHighsLows()` with zone-based detection
|
||||
3. **Historical Data Fix**: Replace time-based with bar-based validation
|
||||
|
||||
### Step 3: Validate Fixes
|
||||
|
||||
1. Run 1-week test to verify pattern detection improvements
|
||||
2. Check for BOS and sweep detection in logs
|
||||
3. Confirm trade execution occurs
|
||||
|
||||
### Step 4: Deploy and Monitor
|
||||
|
||||
1. If 1-week test successful, proceed to 1-month test
|
||||
2. If 1-month test successful, run full 3-month weekend test
|
||||
3. Monitor for memory issues and performance degradation
|
||||
|
||||
## 📞 Next Steps
|
||||
|
||||
Would you like me to:
|
||||
|
||||
1. **Start implementing the BOS detection fix** (highest priority)
|
||||
2. **Create the liquidity sweep zone-based detection** (second priority)
|
||||
3. **Implement all fixes simultaneously** (comprehensive approach)
|
||||
4. **Create a test harness** to validate each fix individually
|
||||
|
||||
The weekend test revealed critical flaws that must be addressed before any live deployment. These fixes will transform the EA from 0% success rate to a functional trading system.
|
||||
@@ -0,0 +1,713 @@
|
||||
//+------------------------------------------------------------------+
|
||||
//| EMERGENCY ALGORITHMIC FIXES FOR SNIPER EA |
|
||||
//| Critical fixes for weekend test failures |
|
||||
//| - BOS Detection Algorithm Overhaul |
|
||||
//| - Liquidity Sweep Zone-Based Detection |
|
||||
//| - Historical Data Processing Fixes |
|
||||
//| - Memory Management Improvements |
|
||||
//+------------------------------------------------------------------+
|
||||
|
||||
//+------------------------------------------------------------------+
|
||||
//| CRITICAL FIX #1: IMPROVED BOS DETECTION ALGORITHM |
|
||||
//+------------------------------------------------------------------+
|
||||
|
||||
// New structure for improved swing point detection
|
||||
struct SwingPointImproved
|
||||
{
|
||||
double price;
|
||||
datetime time;
|
||||
bool is_high;
|
||||
double strength;
|
||||
int detection_method; // 0=3-bar, 1=5-bar, 2=8-bar, 3=13-bar
|
||||
int confirmation_count;
|
||||
};
|
||||
|
||||
// Improved swing point detection with multiple timeframe validation
|
||||
bool FindSwingPointsImproved(string symbol, ENUM_TIMEFRAMES timeframe, int bars_to_analyze,
|
||||
double &swing_highs[], double &swing_lows[],
|
||||
datetime &swing_high_times[], datetime &swing_low_times[])
|
||||
{
|
||||
ArrayResize(swing_highs, 0);
|
||||
ArrayResize(swing_lows, 0);
|
||||
ArrayResize(swing_high_times, 0);
|
||||
ArrayResize(swing_low_times, 0);
|
||||
|
||||
// Use multiple lookback periods for better detection (Fibonacci-based)
|
||||
int lookback_periods[] = {3, 5, 8, 13};
|
||||
double confidence_threshold = 0.6; // Require 60% of bars to confirm swing
|
||||
|
||||
for (int p = 0; p < ArraySize(lookback_periods); p++)
|
||||
{
|
||||
int current_lookback = lookback_periods[p];
|
||||
|
||||
for (int i = current_lookback; i < bars_to_analyze - current_lookback; i++)
|
||||
{
|
||||
// More flexible swing detection - use percentage-based confirmation
|
||||
int higher_count = 0, lower_count = 0;
|
||||
int total_comparison_bars = current_lookback * 2;
|
||||
|
||||
double current_high = iHigh(symbol, timeframe, i);
|
||||
double current_low = iLow(symbol, timeframe, i);
|
||||
|
||||
// Check surrounding bars
|
||||
for (int j = i - current_lookback; j <= i + current_lookback; j++)
|
||||
{
|
||||
if (j != i && j >= 0 && j < iBars(symbol, timeframe))
|
||||
{
|
||||
if (iHigh(symbol, timeframe, j) < current_high)
|
||||
higher_count++;
|
||||
if (iLow(symbol, timeframe, j) > current_low)
|
||||
lower_count++;
|
||||
}
|
||||
}
|
||||
|
||||
// Calculate confidence levels
|
||||
double high_confidence = (double)higher_count / total_comparison_bars;
|
||||
double low_confidence = (double)lower_count / total_comparison_bars;
|
||||
|
||||
// Add swing high if confidence threshold met
|
||||
if (high_confidence >= confidence_threshold)
|
||||
{
|
||||
if (!IsSwingPointDuplicate(swing_highs, swing_high_times, current_high, iTime(symbol, timeframe, i)))
|
||||
{
|
||||
ArrayResize(swing_highs, ArraySize(swing_highs) + 1);
|
||||
ArrayResize(swing_high_times, ArraySize(swing_high_times) + 1);
|
||||
swing_highs[ArraySize(swing_highs) - 1] = current_high;
|
||||
swing_high_times[ArraySize(swing_high_times) - 1] = iTime(symbol, timeframe, i);
|
||||
}
|
||||
}
|
||||
|
||||
// Add swing low if confidence threshold met
|
||||
if (low_confidence >= confidence_threshold)
|
||||
{
|
||||
if (!IsSwingPointDuplicate(swing_lows, swing_low_times, current_low, iTime(symbol, timeframe, i)))
|
||||
{
|
||||
ArrayResize(swing_lows, ArraySize(swing_lows) + 1);
|
||||
ArrayResize(swing_low_times, ArraySize(swing_low_times) + 1);
|
||||
swing_lows[ArraySize(swing_lows) - 1] = current_low;
|
||||
swing_low_times[ArraySize(swing_low_times) - 1] = iTime(symbol, timeframe, i);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Print(StringFormat("Improved swing detection found %d highs and %d lows for %s %s",
|
||||
ArraySize(swing_highs), ArraySize(swing_lows), symbol, EnumToString(timeframe)));
|
||||
|
||||
return ArraySize(swing_highs) > 0 || ArraySize(swing_lows) > 0;
|
||||
}
|
||||
|
||||
// Helper function to prevent duplicate swing points
|
||||
bool IsSwingPointDuplicate(double &existing_prices[], datetime &existing_times[],
|
||||
double new_price, datetime new_time)
|
||||
{
|
||||
double pip_value = 0.0001; // Default for most pairs
|
||||
double tolerance = 5.0 * pip_value; // 5-pip tolerance for duplicates
|
||||
|
||||
for (int i = 0; i < ArraySize(existing_prices); i++)
|
||||
{
|
||||
if (MathAbs(existing_prices[i] - new_price) <= tolerance)
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
//+------------------------------------------------------------------+
|
||||
//| CRITICAL FIX #2: ZONE-BASED LIQUIDITY SWEEP DETECTION |
|
||||
//+------------------------------------------------------------------+
|
||||
|
||||
// New structure for liquidity zones
|
||||
struct LiquidityZone
|
||||
{
|
||||
double upper_bound;
|
||||
double lower_bound;
|
||||
double center_price;
|
||||
datetime formation_time;
|
||||
datetime sweep_time;
|
||||
bool is_high_zone;
|
||||
int touch_count;
|
||||
double zone_strength;
|
||||
bool is_swept;
|
||||
};
|
||||
|
||||
// Improved liquidity sweep detection using zones instead of exact levels
|
||||
bool DetectLiquiditySweepsImproved(string symbol, ENUM_TIMEFRAMES timeframe, LiquiditySweep &sweep_array[])
|
||||
{
|
||||
ArrayResize(sweep_array, 0);
|
||||
|
||||
int bars_to_analyze = MathMin(150, iBars(symbol, timeframe) - 10); // Increased analysis range
|
||||
if (bars_to_analyze < 30)
|
||||
return false;
|
||||
|
||||
Print(StringFormat("Analyzing %d bars for improved liquidity sweeps on %s %s",
|
||||
bars_to_analyze, symbol, EnumToString(timeframe)));
|
||||
|
||||
// Create liquidity zones instead of exact levels
|
||||
LiquidityZone zones[];
|
||||
if (!CreateLiquidityZones(symbol, timeframe, bars_to_analyze, zones))
|
||||
return false;
|
||||
|
||||
// Detect sweeps of liquidity zones
|
||||
for (int i = 0; i < ArraySize(zones); i++)
|
||||
{
|
||||
if (DetectZoneSweep(symbol, timeframe, zones[i]))
|
||||
{
|
||||
LiquiditySweep sweep;
|
||||
sweep.level = zones[i].center_price;
|
||||
sweep.time = zones[i].sweep_time;
|
||||
sweep.is_high_sweep = zones[i].is_high_zone;
|
||||
sweep.confirmed = true; // Zone-based sweeps are auto-confirmed
|
||||
|
||||
ArrayResize(sweep_array, ArraySize(sweep_array) + 1);
|
||||
sweep_array[ArraySize(sweep_array) - 1] = sweep;
|
||||
|
||||
Print(StringFormat("Zone sweep detected: %s at %.5f (zone: %.5f-%.5f)",
|
||||
zones[i].is_high_zone ? "HIGH" : "LOW", zones[i].center_price,
|
||||
zones[i].lower_bound, zones[i].upper_bound));
|
||||
}
|
||||
}
|
||||
|
||||
Print(StringFormat("Found %d zone-based liquidity sweeps on %s %s",
|
||||
ArraySize(sweep_array), symbol, EnumToString(timeframe)));
|
||||
|
||||
return ArraySize(sweep_array) > 0;
|
||||
}
|
||||
|
||||
// Create liquidity zones from price clusters
|
||||
bool CreateLiquidityZones(string symbol, ENUM_TIMEFRAMES timeframe, int bars_to_analyze, LiquidityZone &zones[])
|
||||
{
|
||||
ArrayResize(zones, 0);
|
||||
|
||||
double pip_value = CalculatePipValue(symbol);
|
||||
double zone_width = 10.0 * pip_value; // 10-pip zones (increased from 3-pip exact levels)
|
||||
|
||||
// Get recent significant highs and lows
|
||||
double recent_highs[], recent_lows[];
|
||||
datetime high_times[], low_times[];
|
||||
|
||||
GetRecentSignificantLevels(symbol, timeframe, bars_to_analyze, recent_highs, recent_lows, high_times, low_times);
|
||||
|
||||
// Create zones from clustered highs
|
||||
CreateZonesFromLevels(recent_highs, high_times, true, zone_width, zones);
|
||||
|
||||
// Create zones from clustered lows
|
||||
CreateZonesFromLevels(recent_lows, low_times, false, zone_width, zones);
|
||||
|
||||
Print(StringFormat("Created %d liquidity zones for %s %s", ArraySize(zones), symbol, EnumToString(timeframe)));
|
||||
return ArraySize(zones) > 0;
|
||||
}
|
||||
|
||||
// Get significant price levels for zone creation
|
||||
void GetRecentSignificantLevels(string symbol, ENUM_TIMEFRAMES timeframe, int bars_to_analyze,
|
||||
double &highs[], double &lows[], datetime &high_times[], datetime &low_times[])
|
||||
{
|
||||
ArrayResize(highs, 0);
|
||||
ArrayResize(lows, 0);
|
||||
ArrayResize(high_times, 0);
|
||||
ArrayResize(low_times, 0);
|
||||
|
||||
// Use improved swing detection
|
||||
double swing_highs[], swing_lows[];
|
||||
datetime swing_high_times[], swing_low_times[];
|
||||
|
||||
if (FindSwingPointsImproved(symbol, timeframe, bars_to_analyze, swing_highs, swing_lows, swing_high_times, swing_low_times))
|
||||
{
|
||||
ArrayCopy(highs, swing_highs);
|
||||
ArrayCopy(lows, swing_lows);
|
||||
ArrayCopy(high_times, swing_high_times);
|
||||
ArrayCopy(low_times, swing_low_times);
|
||||
}
|
||||
}
|
||||
|
||||
// Create zones from price level clusters
|
||||
void CreateZonesFromLevels(double &levels[], datetime ×[], bool is_high_zone, double zone_width, LiquidityZone &zones[])
|
||||
{
|
||||
for (int i = 0; i < ArraySize(levels); i++)
|
||||
{
|
||||
double center_price = levels[i];
|
||||
|
||||
// Check if this level is already part of an existing zone
|
||||
bool already_in_zone = false;
|
||||
for (int j = 0; j < ArraySize(zones); j++)
|
||||
{
|
||||
if (center_price >= zones[j].lower_bound && center_price <= zones[j].upper_bound)
|
||||
{
|
||||
already_in_zone = true;
|
||||
zones[j].touch_count++; // Increase zone strength
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (!already_in_zone)
|
||||
{
|
||||
// Create new zone
|
||||
LiquidityZone new_zone;
|
||||
new_zone.center_price = center_price;
|
||||
new_zone.upper_bound = center_price + (zone_width / 2);
|
||||
new_zone.lower_bound = center_price - (zone_width / 2);
|
||||
new_zone.formation_time = times[i];
|
||||
new_zone.is_high_zone = is_high_zone;
|
||||
new_zone.touch_count = 1;
|
||||
new_zone.zone_strength = 1.0;
|
||||
new_zone.is_swept = false;
|
||||
|
||||
ArrayResize(zones, ArraySize(zones) + 1);
|
||||
zones[ArraySize(zones) - 1] = new_zone;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Detect if a liquidity zone has been swept
|
||||
bool DetectZoneSweep(string symbol, ENUM_TIMEFRAMES timeframe, LiquidityZone &zone)
|
||||
{
|
||||
if (zone.is_swept)
|
||||
return false; // Already swept
|
||||
|
||||
int zone_bar = iBarShift(symbol, timeframe, zone.formation_time);
|
||||
if (zone_bar < 0)
|
||||
return false;
|
||||
|
||||
// Look for price action that sweeps through the zone
|
||||
for (int i = 0; i < zone_bar && i < 50; i++) // Increased search range
|
||||
{
|
||||
double bar_high = iHigh(symbol, timeframe, i);
|
||||
double bar_low = iLow(symbol, timeframe, i);
|
||||
double bar_close = iClose(symbol, timeframe, i);
|
||||
|
||||
if (zone.is_high_zone)
|
||||
{
|
||||
// Check for sweep above zone with rejection
|
||||
if (bar_high > zone.upper_bound && bar_close < zone.center_price)
|
||||
{
|
||||
zone.sweep_time = iTime(symbol, timeframe, i);
|
||||
zone.is_swept = true;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// Check for sweep below zone with rejection
|
||||
if (bar_low < zone.lower_bound && bar_close > zone.center_price)
|
||||
{
|
||||
zone.sweep_time = iTime(symbol, timeframe, i);
|
||||
zone.is_swept = true;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
//+------------------------------------------------------------------+
|
||||
//| CRITICAL FIX #3: HISTORICAL DATA PROCESSING FIXES |
|
||||
//+------------------------------------------------------------------+
|
||||
|
||||
// Improved BOS validation using bar-based instead of time-based logic
|
||||
bool IsBOSValidImproved(string symbol, ENUM_TIMEFRAMES timeframe, BreakOfStructure &bos)
|
||||
{
|
||||
// Use bar shift instead of time difference for historical compatibility
|
||||
int bos_bar = iBarShift(symbol, timeframe, bos.time);
|
||||
if (bos_bar < 0)
|
||||
return false;
|
||||
|
||||
// Check if BOS is within reasonable bar distance (not time distance)
|
||||
if (bos_bar > 50) // Increased from previous restrictive limits
|
||||
return false;
|
||||
|
||||
// Validate price action relative to BOS level with buffer
|
||||
double current_price = iClose(symbol, timeframe, 0);
|
||||
double pip_value = CalculatePipValue(symbol);
|
||||
double bos_validation_buffer = 5.0 * pip_value; // 5-pip buffer for validation
|
||||
|
||||
if (bos.is_bullish)
|
||||
{
|
||||
// For bullish BOS, current price should be above level (with buffer)
|
||||
return current_price > (bos.level - bos_validation_buffer);
|
||||
}
|
||||
else
|
||||
{
|
||||
// For bearish BOS, current price should be below level (with buffer)
|
||||
return current_price < (bos.level + bos_validation_buffer);
|
||||
}
|
||||
}
|
||||
|
||||
// Improved liquidity sweep validation using bar-based logic
|
||||
bool IsLiquiditySweepValidImproved(string symbol, ENUM_TIMEFRAMES timeframe, LiquiditySweep &sweep)
|
||||
{
|
||||
if (!sweep.confirmed)
|
||||
return false;
|
||||
|
||||
// Use bar-based validation instead of time-based
|
||||
int sweep_bar = iBarShift(symbol, timeframe, sweep.time);
|
||||
if (sweep_bar < 0 || sweep_bar > 30) // Within 30 bars instead of 10 time periods
|
||||
return false;
|
||||
|
||||
// More flexible price position validation with buffer
|
||||
double current_price = iClose(symbol, timeframe, 0);
|
||||
double pip_value = CalculatePipValue(symbol);
|
||||
double validation_buffer = 8.0 * pip_value; // 8-pip buffer for flexibility
|
||||
|
||||
if (sweep.is_high_sweep)
|
||||
{
|
||||
// For high sweep, price should be below swept level (with buffer)
|
||||
return current_price < (sweep.level + validation_buffer);
|
||||
}
|
||||
else
|
||||
{
|
||||
// For low sweep, price should be above swept level (with buffer)
|
||||
return current_price > (sweep.level - validation_buffer);
|
||||
}
|
||||
}
|
||||
|
||||
//+------------------------------------------------------------------+
|
||||
//| CRITICAL FIX #4: MEMORY MANAGEMENT AND ARRAY CLEANUP |
|
||||
//+------------------------------------------------------------------+
|
||||
|
||||
#define MAX_PATTERN_HISTORY 50
|
||||
#define CLEANUP_FREQUENCY 25
|
||||
|
||||
struct PatternArrayManager
|
||||
{
|
||||
int cleanup_counter;
|
||||
datetime last_cleanup;
|
||||
bool cleanup_enabled;
|
||||
};
|
||||
|
||||
PatternArrayManager g_array_manager = {0, 0, true};
|
||||
|
||||
// Initialize array management system
|
||||
void InitializeArrayManager()
|
||||
{
|
||||
g_array_manager.cleanup_counter = 0;
|
||||
g_array_manager.last_cleanup = TimeCurrent();
|
||||
g_array_manager.cleanup_enabled = true;
|
||||
Print("Pattern Array Manager initialized");
|
||||
}
|
||||
|
||||
// Main cleanup function for all pattern arrays
|
||||
void CleanupPatternArrays(MarketStructureData &mtf_data)
|
||||
{
|
||||
if (!g_array_manager.cleanup_enabled)
|
||||
return;
|
||||
|
||||
g_array_manager.cleanup_counter++;
|
||||
|
||||
if (g_array_manager.cleanup_counter >= CLEANUP_FREQUENCY)
|
||||
{
|
||||
Print(StringFormat("Performing pattern array cleanup (cycle %d)", g_array_manager.cleanup_counter));
|
||||
|
||||
// Clean up old patterns to prevent memory issues
|
||||
int ob_before = ArraySize(mtf_data.order_blocks);
|
||||
int fvg_before = ArraySize(mtf_data.fair_value_gaps);
|
||||
int bos_before = ArraySize(mtf_data.bos_events);
|
||||
int sweep_before = ArraySize(mtf_data.liquidity_sweeps);
|
||||
|
||||
CleanupOldOrderBlocks(mtf_data.order_blocks);
|
||||
CleanupOldFVGs(mtf_data.fair_value_gaps);
|
||||
CleanupOldBOSEvents(mtf_data.bos_events);
|
||||
CleanupOldSweeps(mtf_data.liquidity_sweeps);
|
||||
|
||||
Print(StringFormat("Cleanup completed: OB %d->%d, FVG %d->%d, BOS %d->%d, Sweeps %d->%d",
|
||||
ob_before, ArraySize(mtf_data.order_blocks),
|
||||
fvg_before, ArraySize(mtf_data.fair_value_gaps),
|
||||
bos_before, ArraySize(mtf_data.bos_events),
|
||||
sweep_before, ArraySize(mtf_data.liquidity_sweeps)));
|
||||
|
||||
g_array_manager.cleanup_counter = 0;
|
||||
g_array_manager.last_cleanup = TimeCurrent();
|
||||
}
|
||||
}
|
||||
|
||||
// Cleanup old order blocks
|
||||
void CleanupOldOrderBlocks(OrderBlock &order_blocks[])
|
||||
{
|
||||
if (ArraySize(order_blocks) <= MAX_PATTERN_HISTORY)
|
||||
return;
|
||||
|
||||
// Keep only the most recent patterns
|
||||
int keep_count = MAX_PATTERN_HISTORY;
|
||||
OrderBlock temp_array[];
|
||||
ArrayResize(temp_array, keep_count);
|
||||
|
||||
// Copy most recent patterns
|
||||
for (int i = 0; i < keep_count; i++)
|
||||
{
|
||||
temp_array[i] = order_blocks[ArraySize(order_blocks) - keep_count + i];
|
||||
}
|
||||
|
||||
// Replace original array
|
||||
ArrayResize(order_blocks, keep_count);
|
||||
for (int i = 0; i < keep_count; i++)
|
||||
{
|
||||
order_blocks[i] = temp_array[i];
|
||||
}
|
||||
}
|
||||
|
||||
// Cleanup old FVGs
|
||||
void CleanupOldFVGs(FairValueGap &fvgs[])
|
||||
{
|
||||
if (ArraySize(fvgs) <= MAX_PATTERN_HISTORY)
|
||||
return;
|
||||
|
||||
int keep_count = MAX_PATTERN_HISTORY;
|
||||
FairValueGap temp_array[];
|
||||
ArrayResize(temp_array, keep_count);
|
||||
|
||||
for (int i = 0; i < keep_count; i++)
|
||||
{
|
||||
temp_array[i] = fvgs[ArraySize(fvgs) - keep_count + i];
|
||||
}
|
||||
|
||||
ArrayResize(fvgs, keep_count);
|
||||
for (int i = 0; i < keep_count; i++)
|
||||
{
|
||||
fvgs[i] = temp_array[i];
|
||||
}
|
||||
}
|
||||
|
||||
// Cleanup old BOS events
|
||||
void CleanupOldBOSEvents(BreakOfStructure &bos_events[])
|
||||
{
|
||||
if (ArraySize(bos_events) <= MAX_PATTERN_HISTORY)
|
||||
return;
|
||||
|
||||
int keep_count = MAX_PATTERN_HISTORY;
|
||||
BreakOfStructure temp_array[];
|
||||
ArrayResize(temp_array, keep_count);
|
||||
|
||||
for (int i = 0; i < keep_count; i++)
|
||||
{
|
||||
temp_array[i] = bos_events[ArraySize(bos_events) - keep_count + i];
|
||||
}
|
||||
|
||||
ArrayResize(bos_events, keep_count);
|
||||
for (int i = 0; i < keep_count; i++)
|
||||
{
|
||||
bos_events[i] = temp_array[i];
|
||||
}
|
||||
}
|
||||
|
||||
// Cleanup old liquidity sweeps
|
||||
void CleanupOldSweeps(LiquiditySweep &sweeps[])
|
||||
{
|
||||
if (ArraySize(sweeps) <= MAX_PATTERN_HISTORY)
|
||||
return;
|
||||
|
||||
int keep_count = MAX_PATTERN_HISTORY;
|
||||
LiquiditySweep temp_array[];
|
||||
ArrayResize(temp_array, keep_count);
|
||||
|
||||
for (int i = 0; i < keep_count; i++)
|
||||
{
|
||||
temp_array[i] = sweeps[ArraySize(sweeps) - keep_count + i];
|
||||
}
|
||||
|
||||
ArrayResize(sweeps, keep_count);
|
||||
for (int i = 0; i < keep_count; i++)
|
||||
{
|
||||
sweeps[i] = temp_array[i];
|
||||
}
|
||||
}
|
||||
|
||||
//+------------------------------------------------------------------+
|
||||
//| CRITICAL FIX #5: IMPROVED CONFLUENCE VALIDATION |
|
||||
//+------------------------------------------------------------------+
|
||||
|
||||
struct PatternScore
|
||||
{
|
||||
double sweep_score; // 0-25 points
|
||||
double bos_score; // 0-25 points
|
||||
double fvg_score; // 0-25 points
|
||||
double ob_score; // 0-25 points
|
||||
double total_score; // Sum of all scores
|
||||
string score_breakdown; // Detailed breakdown for logging
|
||||
};
|
||||
|
||||
// Improved confluence validation using scoring system
|
||||
bool ValidateFlexibleConfluenceImproved(string symbol, bool is_bullish, MarketStructureData &m1_data)
|
||||
{
|
||||
Print(StringFormat("=== Improved Confluence Validation for %s %s Setup ===",
|
||||
symbol, is_bullish ? "Bullish" : "Bearish"));
|
||||
|
||||
PatternScore scores;
|
||||
scores.sweep_score = CalculateSweepScore(symbol, is_bullish, m1_data);
|
||||
scores.bos_score = CalculateBOSScore(symbol, is_bullish, m1_data);
|
||||
scores.fvg_score = CalculateFVGScore(symbol, is_bullish, m1_data);
|
||||
scores.ob_score = CalculateOBScore(symbol, is_bullish, m1_data);
|
||||
scores.total_score = scores.sweep_score + scores.bos_score + scores.fvg_score + scores.ob_score;
|
||||
|
||||
scores.score_breakdown = StringFormat("Sweep=%.1f, BOS=%.1f, FVG=%.1f, OB=%.1f",
|
||||
scores.sweep_score, scores.bos_score, scores.fvg_score, scores.ob_score);
|
||||
|
||||
double required_score = 50.0; // Require 50% total score instead of 3/4 criteria
|
||||
|
||||
Print(StringFormat("Pattern Scores: %s, Total=%.1f/100", scores.score_breakdown, scores.total_score));
|
||||
|
||||
if (scores.total_score >= required_score)
|
||||
{
|
||||
Print(StringFormat("Score-based confluence met (%.1f >= %.1f) - executing trade", scores.total_score, required_score));
|
||||
return ExecuteTradeWithScores(symbol, is_bullish, scores, m1_data);
|
||||
}
|
||||
|
||||
Print(StringFormat("Insufficient confluence score (%.1f < %.1f)", scores.total_score, required_score));
|
||||
return false;
|
||||
}
|
||||
|
||||
// Calculate sweep score (0-25 points)
|
||||
double CalculateSweepScore(string symbol, bool is_bullish, MarketStructureData &m1_data)
|
||||
{
|
||||
double score = 0.0;
|
||||
|
||||
for (int i = 0; i < ArraySize(m1_data.liquidity_sweeps); i++)
|
||||
{
|
||||
bool sweep_direction_match = is_bullish ? !m1_data.liquidity_sweeps[i].is_high_sweep : m1_data.liquidity_sweeps[i].is_high_sweep;
|
||||
|
||||
if (sweep_direction_match && IsLiquiditySweepValidImproved(symbol, PERIOD_M1, m1_data.liquidity_sweeps[i]))
|
||||
{
|
||||
score = 25.0; // Full points for valid sweep
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return score;
|
||||
}
|
||||
|
||||
// Calculate BOS score (0-25 points)
|
||||
double CalculateBOSScore(string symbol, bool is_bullish, MarketStructureData &m1_data)
|
||||
{
|
||||
double score = 0.0;
|
||||
|
||||
for (int i = 0; i < ArraySize(m1_data.bos_events); i++)
|
||||
{
|
||||
if (m1_data.bos_events[i].is_bullish == is_bullish &&
|
||||
m1_data.bos_events[i].confirmed &&
|
||||
IsBOSValidImproved(symbol, PERIOD_M1, m1_data.bos_events[i]))
|
||||
{
|
||||
score = 25.0; // Full points for valid BOS
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return score;
|
||||
}
|
||||
|
||||
// Calculate FVG score (0-25 points)
|
||||
double CalculateFVGScore(string symbol, bool is_bullish, MarketStructureData &m1_data)
|
||||
{
|
||||
double score = 0.0;
|
||||
|
||||
for (int i = 0; i < ArraySize(m1_data.fair_value_gaps); i++)
|
||||
{
|
||||
if (m1_data.fair_value_gaps[i].is_bullish == is_bullish &&
|
||||
IsFVGValid(symbol, PERIOD_M1, m1_data.fair_value_gaps[i]))
|
||||
{
|
||||
score = 25.0; // Full points for valid FVG
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return score;
|
||||
}
|
||||
|
||||
// Calculate OB score (0-25 points)
|
||||
double CalculateOBScore(string symbol, bool is_bullish, MarketStructureData &m1_data)
|
||||
{
|
||||
double score = 0.0;
|
||||
double best_strength = 0.0;
|
||||
|
||||
for (int i = 0; i < ArraySize(m1_data.order_blocks); i++)
|
||||
{
|
||||
if (m1_data.order_blocks[i].is_bullish == is_bullish &&
|
||||
m1_data.order_blocks[i].is_fresh &&
|
||||
m1_data.order_blocks[i].strength > best_strength)
|
||||
{
|
||||
best_strength = m1_data.order_blocks[i].strength;
|
||||
}
|
||||
}
|
||||
|
||||
if (best_strength > 0.0)
|
||||
{
|
||||
score = MathMin(25.0, best_strength * 12.5); // Scale strength to 0-25 points
|
||||
}
|
||||
|
||||
return score;
|
||||
}
|
||||
|
||||
// Execute trade with scoring information
|
||||
bool ExecuteTradeWithScores(string symbol, bool is_bullish, PatternScore &scores, MarketStructureData &m1_data)
|
||||
{
|
||||
Print(StringFormat("Executing %s trade for %s with score %.1f (%s)",
|
||||
is_bullish ? "bullish" : "bearish", symbol, scores.total_score, scores.score_breakdown));
|
||||
|
||||
// Find best patterns for trade execution
|
||||
OrderBlock best_ob;
|
||||
FairValueGap best_fvg;
|
||||
LiquiditySweep best_sweep;
|
||||
|
||||
// Get best patterns based on scores
|
||||
if (scores.ob_score > 0)
|
||||
GetBestOrderBlock(symbol, is_bullish, m1_data, best_ob);
|
||||
if (scores.fvg_score > 0)
|
||||
GetBestFVG(symbol, is_bullish, m1_data, best_fvg);
|
||||
if (scores.sweep_score > 0)
|
||||
GetBestSweep(symbol, is_bullish, m1_data, best_sweep);
|
||||
|
||||
// Execute trade using existing trade execution functions
|
||||
if (is_bullish)
|
||||
{
|
||||
return ExecuteBullishTradeWithFibonacci(symbol, best_ob, best_fvg, best_sweep, FibonacciRetracement());
|
||||
}
|
||||
else
|
||||
{
|
||||
return ExecuteBearishTradeWithFibonacci(symbol, best_ob, best_fvg, best_sweep, FibonacciRetracement());
|
||||
}
|
||||
}
|
||||
|
||||
// Helper functions to get best patterns
|
||||
void GetBestOrderBlock(string symbol, bool is_bullish, MarketStructureData &m1_data, OrderBlock &best_ob)
|
||||
{
|
||||
double best_strength = 0.0;
|
||||
int best_index = -1;
|
||||
|
||||
for (int i = 0; i < ArraySize(m1_data.order_blocks); i++)
|
||||
{
|
||||
if (m1_data.order_blocks[i].is_bullish == is_bullish &&
|
||||
m1_data.order_blocks[i].is_fresh &&
|
||||
m1_data.order_blocks[i].strength > best_strength)
|
||||
{
|
||||
best_strength = m1_data.order_blocks[i].strength;
|
||||
best_index = i;
|
||||
}
|
||||
}
|
||||
|
||||
if (best_index >= 0)
|
||||
best_ob = m1_data.order_blocks[best_index];
|
||||
}
|
||||
|
||||
void GetBestFVG(string symbol, bool is_bullish, MarketStructureData &m1_data, FairValueGap &best_fvg)
|
||||
{
|
||||
for (int i = 0; i < ArraySize(m1_data.fair_value_gaps); i++)
|
||||
{
|
||||
if (m1_data.fair_value_gaps[i].is_bullish == is_bullish &&
|
||||
IsFVGValid(symbol, PERIOD_M1, m1_data.fair_value_gaps[i]))
|
||||
{
|
||||
best_fvg = m1_data.fair_value_gaps[i];
|
||||
break; // Take first valid FVG
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void GetBestSweep(string symbol, bool is_bullish, MarketStructureData &m1_data, LiquiditySweep &best_sweep)
|
||||
{
|
||||
for (int i = 0; i < ArraySize(m1_data.liquidity_sweeps); i++)
|
||||
{
|
||||
bool sweep_direction_match = is_bullish ? !m1_data.liquidity_sweeps[i].is_high_sweep : m1_data.liquidity_sweeps[i].is_high_sweep;
|
||||
|
||||
if (sweep_direction_match && IsLiquiditySweepValidImproved(symbol, PERIOD_M1, m1_data.liquidity_sweeps[i]))
|
||||
{
|
||||
best_sweep = m1_data.liquidity_sweeps[i];
|
||||
break; // Take first valid sweep
|
||||
}
|
||||
}
|
||||
}
|
||||
-127
@@ -1,127 +0,0 @@
|
||||
# 🧪 MT5 Sniper EA - Test Suite
|
||||
|
||||
This directory contains all test files, logs, and validation reports for the MT5 Sniper EA project.
|
||||
|
||||
## 📁 **Directory Contents**
|
||||
|
||||
### **Test Files**
|
||||
- `SniperEA_Test.mq5` - Test version of the EA for validation
|
||||
- `VALIDATION_REPORT.md` - Comprehensive validation and testing report
|
||||
|
||||
### **Test Logs**
|
||||
- `20250926.log` - Strategy Tester log from 7-day backtest
|
||||
- **Test Period**: 2025.09.17 to 2025.09.24
|
||||
- **Symbol**: XAUUSD (Gold) M1
|
||||
- **Results**: 1,988,538 pattern detections
|
||||
- **Status**: Phase 1 & 2 validation complete
|
||||
|
||||
## 📊 **Test Results Summary**
|
||||
|
||||
### **Pattern Detection Performance**
|
||||
- **Order Blocks**: 1,068,185 detections ✅
|
||||
- **Fair Value Gaps**: 920,353 detections ✅
|
||||
- **Break of Structure**: Analyzed across all timeframes ✅
|
||||
- **Liquidity Sweeps**: Detection system operational ✅
|
||||
|
||||
### **System Performance**
|
||||
- **Compilation**: 0 errors, 0 warnings ✅
|
||||
- **Processing Speed**: 26ms average per tick ✅
|
||||
- **Memory Usage**: 1.3GB for multi-symbol processing ✅
|
||||
- **Stability**: 100% uptime during test period ✅
|
||||
|
||||
### **Multi-Timeframe Analysis**
|
||||
- **M1**: Primary entry timeframe ✅
|
||||
- **M15**: Short-term bias confirmation ✅
|
||||
- **H4**: Medium-term structure analysis ✅
|
||||
- **D1**: Daily bias calculation ✅
|
||||
- **W1**: Long-term trend confirmation ✅
|
||||
|
||||
## 🎯 **Testing Phases Completed**
|
||||
|
||||
### ✅ **Phase 1: Core Trading Logic**
|
||||
- Smart Money Concepts implementation
|
||||
- Pattern detection algorithms
|
||||
- Trade execution system
|
||||
- Risk management functions
|
||||
|
||||
### ✅ **Phase 2: Multi-Timeframe Integration**
|
||||
- Bias calculation system
|
||||
- Cross-timeframe validation
|
||||
- Major levels detection
|
||||
- Bias change tracking
|
||||
|
||||
## 🔧 **Test Configuration Used**
|
||||
|
||||
```mql5
|
||||
// Risk Management
|
||||
RiskPercent = 1.0
|
||||
MinRR = 2.0
|
||||
MaxTradesPerDay = 3
|
||||
|
||||
// Phase 2 Settings (Adjusted for Testing)
|
||||
MinBiasStrength = 0.0 // Lowered for testing
|
||||
EnableBiasChangeDetection = false // Simplified for testing
|
||||
EnableMajorLevelsFilter = true
|
||||
BiasHistoryPeriods = 10
|
||||
BiasChangeThreshold = 20.0
|
||||
|
||||
// Session Settings
|
||||
UseTimeFilter = false // Disabled for testing
|
||||
```
|
||||
|
||||
## 📈 **Key Findings**
|
||||
|
||||
### **Strengths**
|
||||
1. **Exceptional Pattern Detection**: Nearly 2M patterns detected
|
||||
2. **System Stability**: Zero crashes or errors
|
||||
3. **Professional Architecture**: Clean, maintainable code
|
||||
4. **Multi-Symbol Processing**: Handles 8 symbols simultaneously
|
||||
5. **Memory Efficiency**: Stable operation with large datasets
|
||||
|
||||
### **Conservative Trade Execution**
|
||||
- EA demonstrates professional-grade risk management
|
||||
- Strict confluence requirements prevent over-trading
|
||||
- Conservative approach excellent for capital preservation
|
||||
- Ready for live trading deployment
|
||||
|
||||
## 🚨 **Important Notes**
|
||||
|
||||
### **Test Environment Limitations**
|
||||
- MT5 Strategy Tester has limited higher timeframe data
|
||||
- Some Phase 2 features require live data for full functionality
|
||||
- Conservative trade execution is by design, not a bug
|
||||
|
||||
### **Production Readiness**
|
||||
- ✅ All core systems validated and working
|
||||
- ✅ Pattern detection engine performing excellently
|
||||
- ✅ Risk management systems operational
|
||||
- ✅ Multi-timeframe analysis complete
|
||||
- ✅ Ready for demo/live trading
|
||||
|
||||
## 🔄 **Future Testing**
|
||||
|
||||
### **Recommended Next Steps**
|
||||
1. **Demo Account Testing**: Validate with live data feeds
|
||||
2. **Forward Testing**: Monitor performance in real market conditions
|
||||
3. **Parameter Optimization**: Fine-tune for specific market conditions
|
||||
4. **Extended Backtesting**: Test across different market cycles
|
||||
|
||||
### **Additional Test Scenarios**
|
||||
- High volatility periods
|
||||
- News event handling
|
||||
- Different market sessions
|
||||
- Various symbol characteristics
|
||||
|
||||
## 📝 **Test Reports**
|
||||
|
||||
For detailed analysis and validation results, see:
|
||||
- `VALIDATION_REPORT.md` - Comprehensive testing analysis
|
||||
- `20250926.log` - Raw strategy tester output
|
||||
|
||||
## ⚠️ **Disclaimer**
|
||||
|
||||
These test results are for validation purposes only. Past performance does not guarantee future results. Always conduct your own testing before live deployment.
|
||||
|
||||
---
|
||||
|
||||
**Status**: ✅ **Phase 1 & 2 Testing Complete - Ready for Production!**
|
||||
@@ -1,146 +0,0 @@
|
||||
# SniperEA Validation Report
|
||||
|
||||
## Phase 1: Foundation Setup - COMPLETED ✅
|
||||
|
||||
### 1.1 Main EA Structure
|
||||
- ✅ Created SniperEA.mq5 with standard MQL5 framework
|
||||
- ✅ Implemented OnInit(), OnTick(), OnDeinit() functions
|
||||
- ✅ Added comprehensive input parameters structure
|
||||
- ✅ Created logging and error handling framework
|
||||
- ✅ Successfully compiled and deployed to MT5
|
||||
|
||||
### Key Features Implemented:
|
||||
- **Input Parameters**: 25+ configurable parameters covering all aspects
|
||||
- **Logging System**: Multi-level logging (Info, Warning, Error, Debug, Pattern, Trade)
|
||||
- **Error Handling**: Comprehensive trade error handling with 25+ error codes
|
||||
- **Chart Objects**: Information panel and status display
|
||||
- **Session Management**: GMT-based session detection (Asia, London, New York)
|
||||
|
||||
## Phase 2: Market Structure Detection Core - COMPLETED ✅
|
||||
|
||||
### 2.1 Order Block Detection Algorithm
|
||||
- ✅ Implemented institutional supply/demand zone identification
|
||||
- ✅ Added strength calculation based on multiple factors
|
||||
- ✅ Included freshness validation to avoid stale zones
|
||||
- ✅ Volume analysis for confirmation
|
||||
- ✅ Price rejection validation
|
||||
|
||||
**Algorithm Features:**
|
||||
- Body-to-range ratio analysis (60% minimum)
|
||||
- Volume increase detection (120% of average)
|
||||
- Price rejection confirmation
|
||||
- Strength scoring (0-2.0 scale)
|
||||
- Freshness tracking
|
||||
|
||||
### 2.2 Break of Structure (BOS) Detection
|
||||
- ✅ Implemented swing point identification
|
||||
- ✅ Added BOS pattern recognition for trend changes
|
||||
- ✅ Included confirmation mechanism
|
||||
- ✅ Bullish and bearish BOS detection
|
||||
- ✅ Time-based validation
|
||||
|
||||
**Algorithm Features:**
|
||||
- Swing high/low detection with configurable lookback
|
||||
- Structure break confirmation (2/3 candles minimum)
|
||||
- Recent validity checking
|
||||
- Price respect validation
|
||||
|
||||
### 2.3 Fair Value Gap (FVG) Detection
|
||||
- ✅ Implemented 3-candle gap pattern recognition
|
||||
- ✅ Added minimum gap size filtering
|
||||
- ✅ Included fill status tracking
|
||||
- ✅ Bullish and bearish FVG identification
|
||||
- ✅ Real-time status updates
|
||||
|
||||
**Algorithm Features:**
|
||||
- 3-candle pattern analysis
|
||||
- Minimum gap size (3 pips configurable)
|
||||
- Fill detection and tracking
|
||||
- Midpoint calculation
|
||||
- Price-in-gap validation
|
||||
|
||||
### 2.4 Liquidity Sweep Detection
|
||||
- ✅ Implemented equal highs/lows identification
|
||||
- ✅ Added sweep distance validation
|
||||
- ✅ Included rejection confirmation
|
||||
- ✅ Stop-loss hunting pattern recognition
|
||||
- ✅ Wick-to-body ratio analysis
|
||||
|
||||
**Algorithm Features:**
|
||||
- Equal level detection (2-pip tolerance)
|
||||
- Minimum sweep distance (5 pips configurable)
|
||||
- Rejection confirmation (2:1 wick-to-body ratio)
|
||||
- High and low sweep detection
|
||||
- Recent validity checking
|
||||
|
||||
### 2.5 Multi-Timeframe Analysis Engine
|
||||
- ✅ Implemented 5-timeframe coordination (M1, M15, H4, D1, W1)
|
||||
- ✅ Added market bias calculation
|
||||
- ✅ Included timeframe alignment validation
|
||||
- ✅ Created comprehensive status reporting
|
||||
- ✅ Optimized update frequency per timeframe
|
||||
|
||||
**Engine Features:**
|
||||
- Coordinated analysis across 5 timeframes
|
||||
- Weighted bias calculation (Weekly > Daily > H4)
|
||||
- Signal aggregation and scoring
|
||||
- Alignment validation for trade setups
|
||||
- Efficient update scheduling
|
||||
|
||||
## Compilation Status
|
||||
|
||||
### All Components Successfully Compiled ✅
|
||||
- **Order Block Detection**: ✅ Compiled
|
||||
- **Break of Structure**: ✅ Compiled
|
||||
- **Fair Value Gap Detection**: ✅ Compiled
|
||||
- **Liquidity Sweep Recognition**: ✅ Compiled
|
||||
- **Multi-Timeframe Engine**: ✅ Compiled
|
||||
- **Complete System**: ✅ Compiled and Deployed
|
||||
|
||||
### File Statistics:
|
||||
- **Source File**: src/SniperEA.mq5 (1,850+ lines)
|
||||
- **Compiled File**: src/SniperEA.ex5 (Generated successfully)
|
||||
- **Deployment**: Successfully deployed to MT5 Experts folder
|
||||
|
||||
## Technical Validation
|
||||
|
||||
### Code Quality Metrics:
|
||||
- **Modular Design**: ✅ Separate functions for each component
|
||||
- **Error Handling**: ✅ Comprehensive error management
|
||||
- **Logging**: ✅ Multi-level logging system
|
||||
- **Performance**: ✅ Optimized algorithms with caching
|
||||
- **Memory Management**: ✅ Proper array handling and cleanup
|
||||
|
||||
### MQL5 Standards Compliance:
|
||||
- **Syntax**: ✅ All MQL5 syntax validated
|
||||
- **Functions**: ✅ Proper function declarations and implementations
|
||||
- **Data Types**: ✅ Correct use of MQL5 data types
|
||||
- **API Usage**: ✅ Proper use of MQL5 trading and chart APIs
|
||||
- **Memory**: ✅ No memory leaks detected
|
||||
|
||||
## Next Phase Requirements
|
||||
|
||||
### Phase 3: Trading Logic Implementation
|
||||
The following components are ready for implementation:
|
||||
1. **Entry Signal Validation System** - All detection algorithms ready
|
||||
2. **Trade Execution Engine** - Foundation and error handling ready
|
||||
3. **Risk Management System** - Framework and utilities ready
|
||||
4. **Stop-Loss/Take-Profit Calculation** - Price utilities ready
|
||||
5. **Session-Based Time Filtering** - Session detection ready
|
||||
|
||||
### Integration Points:
|
||||
- Multi-timeframe data is available via `GetTimeframeData()`
|
||||
- Market bias available via `GetMarketBias()`
|
||||
- All pattern detection functions return structured data
|
||||
- Logging and error handling systems are operational
|
||||
|
||||
## Summary
|
||||
|
||||
✅ **Phase 1 & 2 SUCCESSFULLY COMPLETED**
|
||||
- All foundation components implemented and tested
|
||||
- All market structure detection algorithms operational
|
||||
- Multi-timeframe analysis engine fully functional
|
||||
- Complete system compiles without errors
|
||||
- EA successfully deployed to MT5
|
||||
|
||||
The EA now has a solid foundation with sophisticated market structure analysis capabilities. All core detection algorithms are implemented, tested, and ready for integration with trading logic in Phase 3.
|
||||
Reference in New Issue
Block a user