Fracture-5.3.3

Author: Fracture

Okay, here's a breakdown of what this Metatrader script does, explained in a way that avoids technical jargon and focuses on the logic behind its actions:

Overall Purpose

This script is designed to automatically trade on the Forex market. It analyzes price charts and other indicators to decide when to buy or sell a particular currency pair. It aims to profit from both trending and ranging market conditions, while also managing risk and attempting to close trades at a profit.

Key Concepts

Currency Pair: Two currencies that are traded against each other (e.g., EUR/USD).
Buy (Long) and Sell (Short): Actions the script can take. Buying aims to profit if the price goes up, while selling profits when it goes down.
Indicators: Mathematical calculations based on past price data that the script uses to assess market conditions. Examples include moving averages (MAs), Average True Range (ATR), Average Directional Index (ADX) and Fractals.
Lot Size: The amount of currency the script trades in each transaction.
Slippage: The difference between the expected price of a trade and the price at which the trade is actually executed.
Pips: A small unit of measure for currency price changes.
Fractal: Used to identify potential trend reversals.
Drawdown: The measure of how much an account is down from its peak equity.

How It Works: Step-by-Step

Initialization (init()): The script starts by setting things up. This mainly involves running the prepare() function.
Preparation (prepare()): This is the core function that gets everything ready for trading:
- Indicator Calculations: It calculates the values of several technical indicators like ATR, ADX, and Moving Averages. These indicators help the script understand the current market trends and volatility.
- Fractal Detection: It identifies Fractal formations to find potential trend reversals.
- Pip Point Settings: It sets the value of a pip based on the currency pair.
- Historical Data Analysis: It looks back at past trades to calculate the total profit or loss from previous trades.
- Position Analysis: It checks what trades are currently open, how many there are, and their overall profit/loss status.
- Trend Assessment: It evaluates the current market trend, determining if the market is trending strongly in one direction or ranging (moving sideways).
- Lot Size Determination: Based on the account balance, risk settings, and market volatility (ATR), it calculates the appropriate lot size for each trade.
- Displaying Information: It updates the screen with information about the trade space, lot size, trend strength, market conditions, open trades, profit/loss, and historical data.
Trading Logic (start()): This function contains the main trading logic:
- Closing All Trades (CloseAll): If instructed (based on user settings), the script can close all open trades immediately, or close trades when they reach a certain profit level.
- Opening Positions (OpenPosition): If the script is allowed to trade and the number of open trades is below the maximum limit, it decides whether to open a new buy or sell position based on:
  - Market Conditions: If the market is ranging or trending.
  - Indicator Signals: The signals from the indicators (fractals, moving averages, ADX) guide the decision to buy or sell.
  - Existing Positions: The script considers whether it already has positions open and avoids opening too many similar positions.
- Managing Positions (ManagePositions): This handles existing trades:
  - Profit Targets: If the overall profit reaches a certain level, or if past losses are too high compared to recent profits, the script will close all open trades.
  - Trailing Stop-Loss (OrderModify): For certain types of trades ("scalp" trades), the script will adjust the stop-loss level (a price point where the trade automatically closes to limit losses) to lock in profits as the price moves in a favorable direction.

In Summary

This script is an automated Forex trading system that analyzes market data, identifies potential trading opportunities, opens and manages trades, and aims to close them for a profit, all while trying to manage risk. It uses a combination of trend-following and range-trading strategies, adapting its behavior based on changing market conditions.

Orders Execution

Indicators Used

3 Views

0 Downloads

0 Favorites

Fracture-5.3.3

#property copyright "Fracture"
#property link "Fracture"
#define MAGIC 20130704
extern string TOOLS = ".............................................................................................................";
extern bool CloseAll = false;
extern bool ContinueTrading = true;
extern string TRADING = ".............................................................................................................";
extern int QueryHistory = 12;
extern int StartTrades = 6;
extern double BasketProfit = 3;
extern double OpenProfit = 1.3;
extern double TradeSpace = 1.1;
extern double RangingMarket = 0.5;
extern double Aggressive = 8;
extern double DynamicSlippage = 1;
extern double MinProfit = 0.5;
extern double TurboStart = 0.07;
extern double TrendReversal = 0.15;
extern string RISK = ".............................................................................................................";
extern int MaxTrades = 13;
extern double BaseLotSize = 0.01;
extern double RangeUsage = 0.15;
extern double TrendUsage = 0.08;
extern string INDICATOR_ATR = ".............................................................................................................";
extern int ATRTimeFrame = 0;
extern int ATRPeriod = 14;
extern int ATRShift = 0;
extern string INDICATOR_MA = ".............................................................................................................";
extern int MATimeFrame = 0;
extern int MA1Period = 5;
extern int MA2Period = 9;
extern int MA3Period = 22;
extern int MMAShift = 0;
extern int MAShift = 0;
extern string INDICATOR_ADX = ".............................................................................................................";
extern double ADXLine = 40;
extern int ADXTimeFrame = 0;
extern int ADXPeriod = 22;
extern int ADXShift = 0;
extern string INDICATOR_FRACTAL = ".............................................................................................................";
extern int FractalTimeFrame = 0;
extern int FractalShift = 1;
extern int FractalBars = 5;

double slippage, marginRequirement, lotSize, recentProfit, lastProfit, totalHistoryProfit, totalProfit, totalLoss, symbolHistory,
eATR, eATRPrev, eADX, MA1Cur, MA2Cur, MA3Cur, MA1Prev, MA2Prev, MA3Prev ;

int digits, totalTrades;

int totalHistory = 100;
double pipPoints = 0.00010;
double fractalUpPrice = 0 ;
double fractalDownPrice = 0;  
bool nearLongPosition = false;
bool nearShortPosition = false;
double trendStrength = 0;
double drawdown = 0;
bool longTrendUp = false;
bool longTrendDown = false;
bool shortTrendUp = false;
bool shortTrendDown = false;
bool rangingMarket = false;
string display = "\n"; 

int init(){ 
   prepare() ; 
   return( 0 );
}

double marginCalculate( string symbol, double volume ){ 
   return ( MarketInfo( symbol, MODE_MARGINREQUIRED ) * volume ) ; 
} 

void lotSize(){ 
   slippage = NormalizeDouble( ( eATR / pipPoints ) * DynamicSlippage, 1 );
   marginRequirement = marginCalculate( Symbol(), BaseLotSize ); 
   trendStrength = MathAbs( MA1Cur - MA3Cur ) / MathAbs( MA2Cur - MA3Cur );
   drawdown = 1 - AccountEquity() / AccountBalance();
   if( rangingMarket ) lotSize = NormalizeDouble( ( AccountFreeMargin() * RangeUsage / marginRequirement ) * BaseLotSize , 2 ) ;
   else lotSize = NormalizeDouble( ( AccountFreeMargin() * TrendUsage / marginRequirement ) * BaseLotSize, 2 ) ; 
   if( lotSize < 0.01 ) lotSize = 0.01; 
} 

void setPipPoint(){
   digits = MarketInfo( Symbol(), MODE_DIGITS );
   if( digits == 3 ) pipPoints = 0.010;
   else if( digits == 5 ) pipPoints = 0.00010;
} 

void closeAll( string type = "none" ){
   for( int i = 0; i < OrdersTotal(); i++ ) {
   if( OrderSelect( i, SELECT_BY_POS, MODE_TRADES ) == false ) break;
      if( OrderSymbol() == Symbol() ){ 
         RefreshRates();
         if( ( OrderStopLoss() == 0 && OrderProfit() > 0 && type == "profits" ) || type == "none" ){
            if( OrderType() == OP_BUY ) OrderClose( OrderTicket(), OrderLots(), Bid, slippage );
            if( OrderType() == OP_SELL ) OrderClose( OrderTicket(), OrderLots(), Ask, slippage );
         }
      }
   }
}

void prepareFractals(){
   fractalUpPrice = 0;
   fractalDownPrice = 0;
   for( int i = 0; i < FractalBars; i++ ){ 
      double ifractalUp = iFractals( NULL, 0, MODE_UPPER, i );
      double ifractalDown = iFractals( NULL, 0, MODE_LOWER, i );
      if( ifractalUp > 0 && Open[i] > Open[0] ){
         if( Open[i] > Close[i] ) fractalUpPrice = Open[i];
         else fractalUpPrice = Close[i]; 
      } else if( ifractalDown > 0 && Open[i] < Open[0] ){
         if( Open[i] < Close[i] ) fractalDownPrice = Open[i];
         else fractalDownPrice = Close[i];
      }
   }
}

void update(){
   display = "";
   display = display + " Trade Space: " + DoubleToStr( TradeSpace * eATR / pipPoints, 1 ) + "pips";  
   display = display + " Lot Size: " + DoubleToStr( lotSize, 2 ); 
   display = display + "\n\n Trend Strength: " + DoubleToStr( trendStrength, 2 ); 
   display = display + " Ranging: " + DoubleToStr( rangingMarket, 0 );
   display = display + "\n Bull: " + DoubleToStr( longTrendUp, 0 ); 
   display = display + " Bullish: " + DoubleToStr( shortTrendUp, 0 ) ;
   display = display + " Bearish: " + DoubleToStr( shortTrendDown, 0 );
   display = display + " Bear: " + DoubleToStr( longTrendDown, 0 ); 
   display = display + "\n\n Draw Down: " + DoubleToStr( drawdown, 2 );
   display = display + " Open Trades: " + DoubleToStr( totalTrades, 0 ) + " (" + DoubleToStr( MaxTrades, 0 ) + ")";  
   display = display + "\n Profit: " + DoubleToStr( totalProfit, 2 );
   display = display + " Loss: " + DoubleToStr( totalLoss, 2 );
   display = display + " History: " + DoubleToStr( totalHistoryProfit, 2 );
   Comment( display );
}

void prepareHistory(){
   symbolHistory = 0;
   totalHistoryProfit = 0;
   for( int iPos = OrdersHistoryTotal() - 1 ; iPos > ( OrdersHistoryTotal() - 1 ) - totalHistory; iPos-- ){
      OrderSelect( iPos, SELECT_BY_POS, MODE_HISTORY ) ;
      double QueryHistoryDouble = ( double ) QueryHistory;
      if( symbolHistory >= QueryHistoryDouble ) break;
      if( OrderSymbol() == Symbol() ){
         totalHistoryProfit = totalHistoryProfit + OrderProfit() ;
         symbolHistory = symbolHistory + 1 ;
      }
   }
}

void preparePositions() {
   nearLongPosition = false;
   nearShortPosition = false;
   totalTrades = 0;
   totalProfit = 0;
   totalLoss = 0;
   for( int i = 0 ; i < OrdersTotal() ; i++ ) {
      if( OrderSelect( i, SELECT_BY_POS, MODE_TRADES ) == false ) break; 
      if(OrderSymbol() == Symbol()){totalTrades = totalTrades + 1;}
      if( OrderSymbol() == Symbol() && OrderStopLoss() == 0 ) {
         if( rangingMarket && eADX < ADXLine ){
            if( OrderType() == OP_BUY && MathAbs( OrderOpenPrice() - Ask ) < eATR * TradeSpace ) nearLongPosition = true ;
            if( OrderType() == OP_SELL && MathAbs( OrderOpenPrice() - Bid ) < eATR * TradeSpace ) nearShortPosition = true ;
         } else {
            if( OrderType() == OP_BUY && MathAbs( OrderOpenPrice() - Ask ) < eATR * TradeSpace / Aggressive ) nearLongPosition = true ;
            if( OrderType() == OP_SELL && MathAbs( OrderOpenPrice() - Bid ) < eATR * TradeSpace / Aggressive ) nearShortPosition = true ;
         }
         if( OrderProfit() > 0 ) totalProfit = totalProfit + OrderProfit();
         else totalLoss = totalLoss + OrderProfit(); 
      }
   }
}

void prepareIndicators(){
   eATR = iATR( NULL, ATRTimeFrame, ATRPeriod, ATRShift );
   eATRPrev = iATR( NULL, ATRTimeFrame, ATRPeriod, ATRShift + 1 );
   eADX = iADX( NULL, ADXTimeFrame, MA1Period, PRICE_MEDIAN, MODE_MAIN, ADXShift );
   MA1Cur = iMA( NULL, MATimeFrame, MA1Period, MMAShift, MODE_SMMA, PRICE_MEDIAN, MAShift );
   MA2Cur = iMA( NULL, MATimeFrame, MA2Period, MMAShift, MODE_SMMA, PRICE_MEDIAN, MAShift );
   MA3Cur = iMA( NULL, MATimeFrame, MA3Period, MMAShift, MODE_SMMA, PRICE_MEDIAN, MAShift );
   MA1Prev = iMA( NULL, MATimeFrame, MA1Period, MMAShift, MODE_SMMA, PRICE_MEDIAN, MAShift + 1 );
   MA2Prev = iMA( NULL, MATimeFrame, MA2Period, MMAShift, MODE_SMMA, PRICE_MEDIAN, MAShift + 1 );
   MA3Prev = iMA( NULL, MATimeFrame, MA3Period, MMAShift, MODE_SMMA, PRICE_MEDIAN, MAShift + 1 );   
}

void prepare(){
   prepareIndicators();
   prepareFractals();
   setPipPoint(); 
   prepareHistory();
   preparePositions();
   prepareTrend();
   lotSize();   
   update() ;
} 

void openPosition(){ 
   int type = -1;
   if( eADX < ADXLine ){
      if( Close[0] >= fractalUpPrice && Close[0] >= MA1Cur ) type = OP_BUY;
      else if( Close[0] <= fractalDownPrice && Close[0] <= MA1Cur) type = OP_SELL;  
   }  
   if( rangingMarket && eADX < ADXLine ){
      if( !nearLongPosition && type == OP_BUY ) OrderSend( Symbol(), type , lotSize, Ask, slippage, 0, 0, "default", MAGIC ) ;
      else if( !nearShortPosition && type == OP_SELL ) OrderSend( Symbol(), type , lotSize, Bid, slippage, 0, 0, "default", MAGIC ) ;
   } else {
      if( totalTrades > 0 && eADX > ADXLine && drawdown > TurboStart ){ 
         if( drawdown > TrendReversal ){
            if( Close[0] <=  MA1Cur && MA2Cur <= MA3Cur && Close[0] < Open[0] ) type = OP_SELL;
            else if( Close[0] >= MA1Cur && MA2Cur >=  MA3Cur && Close[0] > Open[0] ) type = OP_BUY; 
         } else {
            if( Close[0] <=  MA1Cur && MA2Cur <= MA3Cur && Close[0] < Open[0] ) type = OP_BUY;
            else if( Close[0] >= MA1Cur && MA2Cur >=  MA3Cur && Close[0] > Open[0] ) type = OP_SELL; 
         }
         if( !nearLongPosition && type == OP_BUY ) OrderSend( Symbol(), type , lotSize, Ask, slippage, 0, 0, "scalp", MAGIC ) ;
         else if( !nearShortPosition && type == OP_SELL ) OrderSend( Symbol(), type , lotSize, Bid, slippage, 0, 0, "scalp", MAGIC ) ;
      }
   } 
   if( totalTrades < 1 - ( StartTrades / MaxTrades ) || totalTrades == 0 ){
      if( drawdown < TrendReversal ){
         if( !nearLongPosition && totalTrades == 0 && type == -1 && ( ( eADX > ADXLine ) || ( eADX < ADXLine && Close[0] < Open[0] ) ) ) OrderSend( Symbol(), OP_BUY, lotSize, Ask, slippage, 0, 0, "scalp", MAGIC );
         else if( !nearShortPosition && totalTrades == 0 && type == -1 && ( ( eADX > ADXLine ) ) || ( eADX < ADXLine && Close[0] > Open[0] ) ) OrderSend( Symbol(), OP_SELL, lotSize, Bid, slippage, 0, 0, "scalp", MAGIC );
      } else {
         if( !nearLongPosition && totalTrades == 0 && type == -1 && ( ( eADX > ADXLine ) || ( eADX < ADXLine && Close[0] < Open[0] ) ) ) OrderSend( Symbol(), OP_BUY, lotSize, Ask, slippage, 0, 0, "default", MAGIC );
         else if( !nearShortPosition && totalTrades == 0 && type == -1 && ( ( eADX > ADXLine ) ) || ( eADX < ADXLine && Close[0] > Open[0] ) ) OrderSend( Symbol(), OP_SELL, lotSize, Bid, slippage, 0, 0, "default", MAGIC );
      }
   }
}

void prepareTrend(){
   if( MathAbs( MA2Cur - MA3Cur ) < eATR * RangingMarket ) {
      rangingMarket = true ;
      shortTrendUp = false ;
      shortTrendDown = false ;
      longTrendUp = false ;
      longTrendDown = false ;
   } else {
      if( MA1Cur > MA2Cur && MA1Cur > MA1Prev && MA2Cur > MA2Prev ) shortTrendUp = true ;
      else shortTrendUp = false ;
      if( MA1Cur < MA2Cur && MA1Cur < MA1Prev && MA2Cur < MA2Prev ) shortTrendDown = true ;
      else shortTrendDown = false ;
      if( MA2Cur > MA3Cur && MA2Cur > MA2Prev && MA3Cur > MA3Prev ) longTrendUp = true ;
      else longTrendUp = false ;
      if( MA2Cur < MA3Cur && MA2Cur < MA2Prev && MA3Cur < MA3Prev ) longTrendDown = true ; 
      else longTrendDown = false ;
      if( shortTrendUp || shortTrendDown || longTrendUp || longTrendDown ) rangingMarket = false ;
      else rangingMarket = true ;
   }
}
 
void managePositions(){
   if( ( totalHistoryProfit < 0 || totalTrades == 1 ) && MathAbs( totalHistoryProfit ) < totalProfit * BasketProfit  ) closeAll( "profits" );
   else if( totalTrades > 1 && totalProfit > MathAbs( totalLoss ) * OpenProfit ) closeAll();
   else { 
      for( int i = 0 ; i < OrdersTotal() ; i++ ) {
         if( OrderSelect( i, SELECT_BY_POS, MODE_TRADES ) == false ) break; 
         if( OrderSymbol() == Symbol() && OrderComment() == "scalp" ) {
            if( OrderType() == OP_BUY ) OrderModify( OrderTicket(), OrderOpenPrice(), 0, OrderOpenPrice() + ( MinProfit * eATR ), 0, Orange );
            if( OrderType() == OP_SELL ) OrderModify( OrderTicket(), OrderOpenPrice(), 0, OrderOpenPrice() - ( MinProfit * eATR ), 0, Orange ); 
         } 
      }
   }
}

int start() { 
   prepare() ;  
   if( CloseAll ) closeAll() ;
   else {
      if( ( ContinueTrading || ( !ContinueTrading && totalTrades > 0 ) ) && ( totalTrades < MaxTrades || MaxTrades == 0 ) ) openPosition() ; 
      managePositions() ;
   }
   return( 0 ) ;
}

Symbol:

Time Period:

Comments

Markdown supported. Formatting help

Markdown Formatting Guide

Element	Markdown Syntax
Heading	`# H1 ## H2 ### H3`
Bold	`bold text`
Italic	`italicized text`
Link	`[title](https://www.example.com)`
Image	`![alt text](image.jpg)`
Code	`code`
Code Block	``` code block ```
Quote	`> blockquote`
Unordered List	`- Item 1 - Item 2`
Ordered List	`1. First item 2. Second item`
Horizontal Rule	`---`

Fracture-5.3.3

Similar scripts

Comments

Markdown Formatting Guide