matrix2010/Expert_MACross
1
0
Fork 0
mirror of https://github.com/MajidNamnabat/Expert_MACross.git synced 2025-06-20 11:32:47 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
Expert_MACross/MQL4/Include/MD_V_LAST/EA_MD_TradeManagement.mqh

653 lines
60 KiB
MQL5
Raw Permalink Normal View History

ver0
2024-03-27 12:27:27 +03:30
<EFBFBD><EFBFBD>//+------------------------------------------------------------------+
//| EA_MA_TradeManagement.mqh |
//| Majid Namnabat |
//| https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Majid Namnabat"
#property link "https://www.mql5.com"
#property version "1.00"
#property strict
#include <MD_V_LAST\\EA_MD_UtilityFunctions.mqh>
#include <MD_V_LAST\\EA_MD_Types.mqh>
#include <MD_V_LAST\\EA_MD_IndicatorsInterface.mqh>
#include <MD_V_LAST\\EA_MD_LiveOrderManagement.mqh>
#include <MD_V_LAST\\EA_MD_LadderTradeManagement.mqh>
#include <MD_V_LAST\\EA_MD_ChartCharacteristics.mqh>
enum ENUM_ORDER_STATE // Enumeration of named constants
{
ENUM_ORDER_ZERO=1,
ENUM_ORDER_BUY=2,
ENUM_ORDER_SELL=3,
ENUM_ORDER_BUY_PENDING = 4,
ENUM_ORDER_SELL_PENDING = 5,
ENUM_ORDER_UNKNOWN = 0//,
//ENUM_ORDER_NOTALLOWED_LOCK = 5
};
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
class EA_MA_TradeManagement
{
private:
string m_strSymbol;
int m_nTimeFrame;
double m_fPOINT;
bool m_bOpenOrder_Allow;
public:
CLadderTradeManagement m_oLadderTradeManager;
CAllTradesStatistic m_oTradesStatistics;
CIndicatorsInterface m_oIndicatorsInterface;
ChartCharacteristics m_oChartCharacter;
CLiveOrderManagement m_oLiveOrderManager;
public:
void Prohibit_OpenOrder() {m_bOpenOrder_Allow = false;}
void Allow_OpenOrder() {m_bOpenOrder_Allow = true;}
bool Is_OpenOrder_Allow() {return m_bOpenOrder_Allow;}
EA_MA_TradeManagement();
~EA_MA_TradeManagement();
int DetermineOrderState(ENUM_ORDERS_INVESTIGATE_STATE nInvestigateState);
bool IsMustNowRest_CauseBigLoss(int nRestHours, double fBalanceRiskVolume,double fLoss_RiskBalance_Ratio_Rest);
bool TimeManager_AllowOpen(ENUM_TIME_TRADE_MANAGEMENT nTimeTradeSetting);
bool TimeManager_MustCloseOrder(ENUM_TIME_TRADE_MANAGEMENT nTimeTradeSetting);
bool CheckPending_Activated();
void Setup(string strSymbol, int nTimeFrame,
ENUM_NORMAL_MV nFastMVPeriod, ENUM_MA_METHOD nFastMVType,
ENUM_NORMAL_MV nSlowMVPeriod, ENUM_MA_METHOD nSlowMVType,
ENUM_CUSTOM_APPLIED_PRICE nActiveCloseOrderCurrentCandle,
datetime dtExpert_TimeInit);
void OpenInitOrder(int nCommand);
bool MustOpenOrder(int& nCommand, bool isCandleTick, bool isNewBar,bool isForex, int nHigherPeriod, int nLowerPeriod, bool isHigherPeriodNewBar);
void ExistingOrdersManagement(ENUM_ORDERS_INVESTIGATE_STATE nInvestigateMethod, bool isCandleTick);
bool IsMustRest_CauseBigLoss();
bool DetermineOpenAllowance(int nOrderState);
bool CheckAngle_Stop(int nCommand, double fSL_Origin);
bool CheckAngle_Order(int nCommand, double fOpenPrice);
};
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
EA_MA_TradeManagement::EA_MA_TradeManagement()
{
m_bOpenOrder_Allow = true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
EA_MA_TradeManagement::~EA_MA_TradeManagement()
{
}
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
void EA_MA_TradeManagement::Setup(string strSymbol, int nTimeFrame,
ENUM_NORMAL_MV nFastMVPeriod, ENUM_MA_METHOD nFastMVType,
ENUM_NORMAL_MV nSlowMVPeriod, ENUM_MA_METHOD nSlowMVType,
ENUM_CUSTOM_APPLIED_PRICE nActiveCloseOrderCurrentCandle, datetime dtExpert_TimeInit)
{
if(strSymbol!=m_strSymbol || nTimeFrame!=m_nTimeFrame || m_strSymbol=="")
{
m_oLadderTradeManager.ResetHistory();
}
m_strSymbol = strSymbol;
m_nTimeFrame = nTimeFrame;
m_fPOINT = SymbolInfoDouble(m_strSymbol,SYMBOL_POINT);
//m_nOrderState = ENUM_ORDER_UNKNOWN;
m_bOpenOrder_Allow = true;
m_oIndicatorsInterface.Setup(m_strSymbol,m_nTimeFrame,
nFastMVPeriod,nFastMVType,
nSlowMVPeriod,nSlowMVType,
nActiveCloseOrderCurrentCandle);
m_oLadderTradeManager.Setup(m_oChartCharacter,m_oIndicatorsInterface,m_strSymbol,m_nTimeFrame);
m_oLiveOrderManager.Setup(m_oTradesStatistics,m_oIndicatorsInterface,m_oLadderTradeManager,m_strSymbol,m_nTimeFrame);
m_oChartCharacter.Setup(m_strSymbol,m_nTimeFrame,m_oIndicatorsInterface);
double isAnalyseShortTermTrades = (ActiveBreakEvenDistance == ENUM_BREAKEVEN_INTELLIGENT);
m_oTradesStatistics.Insert_Symbol_TF(m_strSymbol,m_nTimeFrame, isAnalyseShortTermTrades,dtExpert_TimeInit);
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
int EA_MA_TradeManagement::DetermineOrderState(ENUM_ORDERS_INVESTIGATE_STATE nInvestigateState)
{
int nSell=0,nBuy=0,nPendingSell=0,nPendingBuy=0,nTotalMarketOrder;
string strSymbol = (nInvestigateState == ENUM_ORDERS_INVESTIGATE_ALL) ? "" : m_strSymbol;
nTotalMarketOrder = SpecialOrdersTotal(strSymbol,MACROSS_MAGIC_NUM,nBuy,nSell,nPendingBuy,nPendingSell);
int nOrderState = ENUM_ORDER_UNKNOWN;
nOrderState = (nTotalMarketOrder == 0 && nPendingBuy == 0 && nPendingSell == 0) ? SetBit(nOrderState,ENUM_ORDER_ZERO) : nOrderState;
nOrderState |= (nSell > 0 && nBuy == 0) ? SetBit(nOrderState,ENUM_ORDER_SELL) : nOrderState;
nOrderState |= (nSell == 0 && nBuy > 0) ? SetBit(nOrderState,ENUM_ORDER_BUY) : nOrderState;
nOrderState |= (nSell == 0 && nBuy == 0 && nPendingBuy > 0) ? SetBit(nOrderState,ENUM_ORDER_BUY_PENDING) : nOrderState;
nOrderState |= (nSell == 0 && nBuy == 0 && nPendingSell > 0) ? SetBit(nOrderState,ENUM_ORDER_SELL_PENDING) : nOrderState;
//if(IS_ENABLE_LOG) Print("EATradeManager::DetermineOrderState " , nOrderState , " " );
return nOrderState;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool EA_MA_TradeManagement::IsMustNowRest_CauseBigLoss(int nRestHours, double fBalanceRiskVolume,double fLoss_RiskBalance_Ratio_Rest)
{
datetime dtLastOrderCloseTime = 0 ;
double fProfit = GetProfits(m_strSymbol, MACROSS_MAGIC_NUM, 1,dtLastOrderCloseTime);
if(fProfit >= 0)
{
return false;
}
//double fInitialDeposit = AccountInfoDouble(ACCOUNT_BALANCE)- AccountInfoDouble(ACCOUNT_PROFIT);
//double fInitialDeposit = TesterStatistics(STAT_INITIAL_DEPOSIT) ; //GetInitialDeposit();
//if(IS_ENABLE_LOG) Print("IsMustNowRest_CauseBigLoss fInitialDeposit " , fInitialDeposit );
//10% of Initial Balance
//if( fProfit < 0 && MathAbs(fProfit) > (0.1 * fInitialDeposit ) )
//2.5% of Balance
if(fProfit < 0 && MathAbs(fProfit) > ((fBalanceRiskVolume) * AccountInfoDouble(ACCOUNT_BALANCE)) && 0)
{
int nDuration =(int)((TimeCurrent() - dtLastOrderCloseTime) / 3600) ; // in hour
if(nDuration < nRestHours)
{
/*if(nDuration < 1)
if(IS_ENABLE_LOG) Print("In Rest_CauseBigLost");
*/
return true;
}
}
else
{
double fProfit3Last = GetProfits(m_strSymbol, MACROSS_MAGIC_NUM,3,dtLastOrderCloseTime);
if(fProfit < 0 && fProfit3Last< 0 && MathAbs(fProfit3Last) > ((fLoss_RiskBalance_Ratio_Rest*fBalanceRiskVolume) * AccountInfoDouble(ACCOUNT_BALANCE)))
{
int nDuration =(int)((TimeCurrent() - dtLastOrderCloseTime) / 3600) ; // in hour
if(nDuration < nRestHours)
{
/*
if(nDuration < 1)
if(IS_ENABLE_LOG) Print("In Rest_CauseBigLost");
*/
return true;
}
}
}
return false;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool EA_MA_TradeManagement::TimeManager_AllowOpen(ENUM_TIME_TRADE_MANAGEMENT nTimeTradeSetting)
{
if(DayOfWeek() != 0 && DayOfWeek() != 6 && DayOfWeek() != 5) // 5 is Friday
return true;
switch(nTimeTradeSetting)
{
case ENUM_TIME_TRADE_FRIDAY_ALL_NOT_OPEN :
case ENUM_TIME_TRADE_HOLIDAY_OFFSET_FRIDAY_NOT_OPEN:
return false;
break;
case ENUM_TIME_TRADE_FRIDAY_AFTERNOON_NOT_OPEN:
case ENUM_TIME_TRADE_HOLIDAY_OFFSET_FRIDAY_AFTERNOON_NOT_OPEN:
if(DayOfWeek() == 5 && Hour() > 15)
{
//if(IS_ENABLE_LOG) Print("TimeManager_AllowOpen : Return False");
return false;
}
if(DayOfWeek() == 0 || DayOfWeek() == 6)
{
return false;
}
break;
}
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool EA_MA_TradeManagement::TimeManager_MustCloseOrder(ENUM_TIME_TRADE_MANAGEMENT nTimeTradeSetting)
{
switch(nTimeTradeSetting)
{
case ENUM_TIME_TRADE_HOLIDAY_OFFSET_FRIDAY_AFTERNOON_NOT_OPEN:
case ENUM_TIME_TRADE_HOLIDAY_OFFSET_FRIDAY_NOT_OPEN:
//if(IS_ENABLE_LOG) Print("TimeManager_MustCloseOrder ",DayOfWeek(),Hour());
if(DayOfWeek() == 5 && Hour() == 23 && Minute() > 30) // ~F,4F(G 3'9* 11.5 4(
{
//if(IS_ENABLE_LOG) Print("TimeManager_MustCloseOrder : Return True");
return true;
}
else
return false;
break;
}
return false;
}
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool EA_MA_TradeManagement::CheckPending_Activated()
{
if(m_oLadderTradeManager.m_oTradeHistory.m_fInitialLots > 0.000001)
return true;
if(OrderSelect(m_oLadderTradeManager.m_oTradeHistory.m_nInitOrder_Ticket, SELECT_BY_TICKET, MODE_TRADES) == false)
{
if(IS_ENABLE_LOG)
Print("ERROR - Unable to select the order - ",GetLastError());
return false;
}
//it is activated
if(OrderType()== OP_BUY || OrderType()== OP_SELL)
{
m_oLadderTradeManager.m_oTradeHistory.m_fInitialLots = OrderLots();
/*m_nOrderState = (OrderType()== OP_BUY) ? ENUM_ORDER_BUY : m_nOrderState;
m_nOrderState = (OrderType()== OP_SELL) ? ENUM_ORDER_SELL : m_nOrderState;*/
return true;
}
return false;
}
//+------------------------------------------------------------------+
void EA_MA_TradeManagement::OpenInitOrder(int nCommand)
{
bool bActPending = false;
RefreshRates();
double fOpenPrice=0.f;
double fSLPrice=0.f;
double fTPPrice=0.f;
int nCoef = 1 ;
ENUM_HT_CLOSEPRICE_STATUS nHFTrendResult = ENUM_HT_STATUS_UNKNOWN;
int nSLDistance_InPip = 0 ;
double fPendingOrderOpenPrice = 0.f;
double fAsk = SymbolInfoDouble(m_strSymbol,SYMBOL_ASK); // Best Buy Offer
double fBid = SymbolInfoDouble(m_strSymbol,SYMBOL_BID); // Best Buy Offer
double fMarkPrice = nCommand==OP_BUY ? fAsk : fBid;
double fSLPrice_Origin = 0.f;
ENUM_TRACK_ORDER_TRADE nTrackOrderTrade = ENUM_TRACK_ORDER_INIT;
nCoef = nCommand==OP_BUY ? 1 : -1;
// in roboforex test , one trade one candle after cause call margin ,
//Not acceptable never , so stoploss must set always when order init
fSLPrice= m_oLiveOrderManager.DetermineStopLossValue(nCommand, fMarkPrice,fSLPrice_Origin);
nSLDistance_InPip = fSLPrice > 0.000001 ? (int) MathRound((MathAbs(fMarkPrice - fSLPrice_Origin) / m_fPOINT)) : 999999 ;
if(IS_ENABLE_LOG)
Print("OpenInitOrder nSLDistance_InPip : ", nSLDistance_InPip, " SLPrice: ", fSLPrice, " SLPriceOrigin: ", fSLPrice_Origin, " MarkPrice: ", fMarkPrice);
switch(m_nInitOrderSetRule)
{
case ENUM_INITORDER_SET_ALLSPOT :
bActPending = false;
break;
case ENUM_INITORDER_SET_STOPDISTANCE_ADJUSTMENT :
fPendingOrderOpenPrice = m_oIndicatorsInterface.m_oMVCrossDis.GetMovingAverageFastValue() + nCoef * 0 * MVsMinOpenDistance * m_fPOINT;
if(fPendingOrderOpenPrice >= fMarkPrice && nCommand==OP_BUY)
bActPending = false;
if(fPendingOrderOpenPrice <= fMarkPrice && nCommand==OP_SELL)
bActPending = false;
//Experience Amazing In RoboForex XAUUSD AS Underestanding , More Distance From Slow MV
//( more distance from StopLoss) is more profitable )
if(nSLDistance_InPip < 1.5 * MVsMinOpenDistance)
bActPending = true;
else
bActPending = false;
break;
case ENUM_INITORDER_SET_HFTREND_ADJUSTMENT :
nHFTrendResult = (ENUM_HT_CLOSEPRICE_STATUS) m_oIndicatorsInterface.Get_HalfTrend_Buf(0,2, 2, false, false);
if(nCommand == OP_BUY && nHFTrendResult == ENUM_HT_BULLISH_OUT_UPCHANNEL)
{
bActPending = true;
fPendingOrderOpenPrice = fMarkPrice - nCoef * 10 * m_fPOINT;
}
else
if(nCommand == OP_SELL && nHFTrendResult == ENUM_HT_BEARISH_OUT_DOWNCHANNEL)
{
bActPending = true;
fPendingOrderOpenPrice = fMarkPrice - nCoef * 10 * m_fPOINT;
}
else
bActPending = false;
break;
case ENUM_INITORDER_SET_ALLPENDING :
bActPending = true;
fPendingOrderOpenPrice = fMarkPrice - nCoef * 3 * m_fPOINT;
break;
}
if(!bActPending)
{
fOpenPrice = fMarkPrice;
}
else
{
fOpenPrice = NormalizePrice(fPendingOrderOpenPrice,NULL);
fSLPrice= m_oLiveOrderManager.DetermineStopLossValue(nCommand, fOpenPrice,fSLPrice_Origin);
nSLDistance_InPip = fSLPrice > 0.000001 ? (int) MathRound((MathAbs(fOpenPrice - fSLPrice_Origin) / m_fPOINT)) : 999999 ;
if(nCommand == OP_BUY)
nCommand = OP_BUYLIMIT;
else
if(nCommand == OP_SELL)
nCommand = OP_SELLLIMIT;
nTrackOrderTrade = ENUM_TRACK_ORDER_INIT_PENDING;
}
fTPPrice=ManualTakeProfit != 0 ? (fOpenPrice + nCoef * ManualTakeProfit*m_fPOINT) : fTPPrice ;
double fLots = m_oLiveOrderManager.OrderLotDetermine_SL_Risk_Base(nSLDistance_InPip,fOpenPrice);
if(fLots < 0.0001)
return;
if(fSLPrice_Origin==0.f)
{
Print("OpenInitOrder fSLPrice_Origin==0.f Err!!!", fSLPrice_Origin);
}
if(CheckAngle_Order(nCommand,fOpenPrice) && CheckAngle_Stop(nCommand,fSLPrice_Origin))
{
int nTicket = COrdersManagement::OpenOrder(m_strSymbol,MACROSS_MAGIC_NUM, nCommand, fOpenPrice, fLots, fSLPrice, fTPPrice,DoubleToStr(fSLPrice_Origin)) ;
if(nTicket>0)
{
m_oLadderTradeManager.ChangeHistory(nTrackOrderTrade, fLots, fOpenPrice, nTicket, TimeCurrent());
m_oTradesStatistics.OrderOpened(m_strSymbol,m_nTimeFrame,nCommand, nTicket,fLots,fOpenPrice, TimeCurrent(),
m_oIndicatorsInterface.m_oMVCrossDis.GetMovingAverageFastValue(),
m_oIndicatorsInterface.m_oMVCrossDis.GetMovingAverageSlowValue(),
nSLDistance_InPip);
}
}
else
{
Print("CheckAngle Not Allows");
Prohibit_OpenOrder();
}
/*
double PipValue = MarketInfo(m_strSymbol, MODE_TICKVALUE); // Pip Value in the deposit currency
double PipSize = MarketInfo(m_strSymbol, MODE_TICKSIZE); // Pip Size in the quote currency
*/
}
//+------------------------------------------------------------------+
bool EA_MA_TradeManagement::MustOpenOrder(int& nCommand, bool isCandleTick, bool isNewBar,bool isForex, int nHigherPeriod, int nLowerPeriod, bool isHigherPeriodNewBar)
{
bool bIsMVPriceStateSuitable_Buy = false, bIsMVPriceStateSuitable_Sell =false ;
ENUM_WAVE_TREND nTrendDirection = ENUM_TREND_UNKNOWN ;
int nOrderState = DetermineOrderState(ENUM_ORDERS_INVESTIGATE_ALL);
if(isCandleTick && (m_nIs_ExitSignal_NonMVMethod == ENUM_EXITSIGNAL_NONMV_METHOD_CANDLESTICK_AND_DIVERGENCE ||
m_nIs_ExitSignal_NonMVMethod == ENUM_EXITSIGNAL_NONMV_METHOD_ONLY_DIVERGENCE ||
m_nIs_ExitSignal_NonMVMethod == ENUM_EXITSIGNAL_NONMV_METHOD_DIVERGENCE_SATURATION))
{
m_oChartCharacter.Determine_CandleStick(isForex);
m_oChartCharacter.Determine_MACD_Divergene(nHigherPeriod,nLowerPeriod,isHigherPeriodNewBar);
}
if(IsBitOn(nOrderState, ENUM_ORDER_ZERO) && isNewBar)
{
switch(OrderAsTrend)
{
case ENUM_TREND_GOLDENCROSS :
nTrendDirection = m_oIndicatorsInterface.GoldenDeathCrossStatus(0);
break;
case ENUM_TREND_GOLDENCROSS_HIGHER :
nTrendDirection = m_oIndicatorsInterface.GoldenDeathCrossStatus(nHigherPeriod);
break;
case ENUM_TREND_HIGHER_TIMEFRAME :
nTrendDirection = m_oIndicatorsInterface.HigherTimeFrameTrendDetermine(nHigherPeriod);
break;
case ENUM_TREND_WEEKLY_CANDLE:
nTrendDirection = m_oIndicatorsInterface.WeeklyTrendDetermine();
break;
case ENUM_TREND_DETERMINE_NONE:
nTrendDirection = ENUM_TREND_UNKNOWN;
break;
}
double fAsk = SymbolInfoDouble(m_strSymbol,SYMBOL_ASK); // Best Buy Offer
double fBid = SymbolInfoDouble(m_strSymbol,SYMBOL_BID); // Best Buy Offer
bIsMVPriceStateSuitable_Buy = (m_oChartCharacter.m_nMVStates == ENUM_MV_CROSSOVER &&
m_oIndicatorsInterface.m_oMVCrossDis.GetIsCrossOccurred() &&
m_oIndicatorsInterface.m_oMVCrossDis.GetMVDistanceInPoint() > 0 &&
m_oIndicatorsInterface.m_oMVCrossDis.GetMVDistanceInPoint() > MVsMinOpenDistance &&
fAsk >= m_oIndicatorsInterface.m_oMVCrossDis.GetMovingAverageSlowValue());
bIsMVPriceStateSuitable_Sell = (
m_oChartCharacter.m_nMVStates == ENUM_MV_CROSSOVER &&
m_oIndicatorsInterface.m_oMVCrossDis.GetIsCrossOccurred() &&
m_oIndicatorsInterface.m_oMVCrossDis.GetMVDistanceInPoint() < 0 &&
MathAbs(m_oIndicatorsInterface.m_oMVCrossDis.GetMVDistanceInPoint()) > MVsMinOpenDistance &&
fBid <= m_oIndicatorsInterface.m_oMVCrossDis.GetMovingAverageFastValue());
//Print ("MustOpenOrder : Symbol : ", m_strSymbol , " isNewBar , bIsMVPriceStateSuitable_Buy : " , bIsMVPriceStateSuitable_Buy , " bIsMVPriceStateSuitable_Sell : " ,bIsMVPriceStateSuitable_Sell , " MVDistance : " , m_oIndicatorsInterface.m_oMVCrossDis.GetMVDistanceInPoint());
if(bIsMVPriceStateSuitable_Buy || bIsMVPriceStateSuitable_Sell)
{
m_oChartCharacter.m_nMVStates = ENUM_MV_DISTANCE_SUITABLE_OPEN;
if(IS_ENABLE_LOG)
Print(" ENUM_MV_DISTANCE_SUITABLE_OPEN Symbol : ", m_strSymbol, " OrderAsTrend : ", EnumToString(OrderAsTrend), " TrendDirection : ", EnumToString(nTrendDirection));
switch(nTrendDirection)
{
case ENUM_TREND_BULLISH:
if(m_oIndicatorsInterface.m_oMVCrossDis.GetMVDistanceInPoint() < 0 && m_oChartCharacter.m_nMVStates == ENUM_MV_DISTANCE_SUITABLE_OPEN) //CrossDown
{
Prohibit_OpenOrder();
if(IS_ENABLE_LOG)
Print("Decision Make Prohibit_OpenOrder");
}
break;
case ENUM_TREND_BEARISH:
if(m_oIndicatorsInterface.m_oMVCrossDis.GetMVDistanceInPoint() > 0 && m_oChartCharacter.m_nMVStates == ENUM_MV_DISTANCE_SUITABLE_OPEN) //CrossUp
{
Prohibit_OpenOrder();
//if(IS_ENABLE_LOG)
Print("Decision Make Prohibit_OpenOrder");
}
break;
case ENUM_TREND_NEURAL:
Prohibit_OpenOrder();
//if(IS_ENABLE_LOG) Print("Decision Make Prohibit_OpenOrder");
break;
}
}
}
bool bFullCloseCondition = false;
if(IsBitOn(nOrderState,ENUM_ORDER_ZERO))
{
if(bIsMVPriceStateSuitable_Buy &&
Is_OpenOrder_Allow() &&
m_oIndicatorsInterface.m_oMVCrossDis.GetCurrentCandle_MVTrend() == ENUM_TREND_BULLISH)
{
//E<EFBFBD>.H'GE /1 ~HD(<EFBFBD> G' (G .7H7 E<EFBFBD>'F<EFBFBD><EFBFBD>F "FG' 1' <00><06>1 (<06>F/'2E
// (F81E '4*('G '3*  1HF/G'<EFBFBD> ~1319* 1' FE<EFBFBD> <EFBFBD><EFBFBD>1/ H '<EFBFBD>F (/ G3*
// /1 1HF/G'<EFBFBD> ~1319* '5D' A<EFBFBD>/(<EFBFBD><EFBFBD> 5H1* FE<EFBFBD> <EFBFBD><EFBFBD>1/
ENUM_RISK_DEGREE nRiskDegree = m_oChartCharacter.OpenOrder_RiskAnalysis(OP_BUY,m_nOpenOrder_RiskAnalysis);
if(IS_ENABLE_LOG)
Print("OpenNewOrder-Buy MVDistancePoint = ",m_oIndicatorsInterface.m_oMVCrossDis.GetMVDistanceInPoint(), " Risk : ", EnumToString(nRiskDegree));
if(nRiskDegree != ENUM_RISK_HIGH && nRiskDegree != ENUM_RISK_VERY_HIGH)
{
nCommand = OP_BUY;
return true;
}
}
if(bIsMVPriceStateSuitable_Sell &&
Is_OpenOrder_Allow() &&
m_oIndicatorsInterface.m_oMVCrossDis.GetCurrentCandle_MVTrend() == ENUM_TREND_BEARISH)
{
ENUM_RISK_DEGREE nRiskDegree = m_oChartCharacter.OpenOrder_RiskAnalysis(OP_SELL,m_nOpenOrder_RiskAnalysis);
if(IS_ENABLE_LOG)
Print("OpenNewOrder - Sell MVDistancePoint = ",m_oIndicatorsInterface.m_oMVCrossDis.GetMVDistanceInPoint(), "Risk : ", EnumToString(nRiskDegree));
if(nRiskDegree != ENUM_RISK_HIGH && nRiskDegree != ENUM_RISK_VERY_HIGH)
{
nCommand = OP_SELL;
return true;
}
}
}
return false;
}
//+------------------------------------------------------------------+
void EA_MA_TradeManagement::ExistingOrdersManagement(ENUM_ORDERS_INVESTIGATE_STATE nInvestigateMethod, bool isCandleTick)
{
int nCommand = OP_BUY;
int nOrderState = DetermineOrderState(ENUM_ORDERS_INVESTIGATE_SYMBOL_ONLY);
if(IsBitOn(nOrderState,ENUM_ORDER_ZERO))
return;
if(TimeManager_MustCloseOrder(m_nTimeTradeManager))
{
COrdersManagement::RemoveAllPendings(m_strSymbol,MACROSS_MAGIC_NUM);
if(IsBitOn(nOrderState, ENUM_ORDER_BUY) ||
IsBitOn(nOrderState, ENUM_ORDER_SELL))
{
if(IS_ENABLE_LOG)
Print("TimeManager_MustCloseOrder return TRUE ");
m_oLiveOrderManager.CloseInitOrders(IsBitOn(nOrderState, ENUM_ORDER_BUY) ? OP_BUY : OP_SELL);
}
return;
}
bool bFullCloseCondition = false;
if(IsBitOn(nOrderState,ENUM_ORDER_BUY))
{
nCommand = OP_BUY ;
bFullCloseCondition = (m_oIndicatorsInterface.m_oMVCrossDis.GetMVDistanceInPoint() >= 0 && m_oIndicatorsInterface.m_oMVCrossDis.GetMVDistanceInPoint() <= MVsMaxCloseDistance) || (m_oIndicatorsInterface.m_oMVCrossDis.GetMVDistanceInPoint() < 0);
}
else
if(IsBitOn(nOrderState,ENUM_ORDER_SELL))
{
nCommand = OP_SELL ;
bFullCloseCondition = (m_oIndicatorsInterface.m_oMVCrossDis.GetMVDistanceInPoint() <= 0 && MathAbs(m_oIndicatorsInterface.m_oMVCrossDis.GetMVDistanceInPoint()) <= MVsMaxCloseDistance) || (m_oIndicatorsInterface.m_oMVCrossDis.GetMVDistanceInPoint() > 0);
}
if(bFullCloseCondition)
{
m_oChartCharacter.m_nMVStates = ENUM_MV_DISTANCE_SUITABLE_CLOSE;
if(IS_ENABLE_LOG)
Print("CloseOrder-Buy MVDistancePoint = ",m_oIndicatorsInterface.m_oMVCrossDis.GetMVDistanceInPoint());
m_oLiveOrderManager.CloseInitOrders(nCommand);
return;
}
else
{
if(isCandleTick)
{
if(m_nIs_ExitSignal_NonMVMethod != ENUM_EXITSIGNAL_NONMV_METHOD_DISABLE && m_oLadderTradeManager.IsExitPoint_NonMVMethod(nCommand))
{
if(IS_ENABLE_LOG)
Print("m_nIs_ExitSignal_NonMVMethod != ENUM_EXITSIGNAL_NONMV_METHOD_DISABLE ");
ENUM_ORDER_SIZE nRatio = ENUM_ORDER_SIZE_STEP;
if(m_nActiveStairTradingManagement == ENUM_STAIRTRADING_MANAGEMENT_NONE)
m_oLiveOrderManager.CloseInitOrders(nCommand);
else
{
if(m_oLadderTradeManager.ExitSignals_Decision(nRatio))
{
switch(nRatio)
{
case ENUM_ORDER_SIZE_FULL :
if(IS_ENABLE_LOG)
Print("ExitSignals_Decision Return Full");
m_oLiveOrderManager.CloseInitOrders(nCommand);
break;
case ENUM_ORDER_SIZE_STEP :
//Print ("ExitSignals_Decision Return ENUM_ORDER_SIZE_STEP");
if(m_oLadderTradeManager.Allow_StepTrade())
m_oLiveOrderManager.CloseStepOrder(nCommand);
break;
}
}
}
}
if((m_nActiveStairTradingManagement == ENUM_STAIRTRADING_MANAGEMENT_SIMPLE_COMPENSATE ||
m_nActiveStairTradingManagement == ENUM_STAIRTRADING_MANAGEMENT_STC_COMPENSATE ||
m_nActiveStairTradingManagement == ENUM_STAIRTRADING_MANAGEMENT_MACD_SIGNAL_COMPENSATE) &&
m_oLadderTradeManager.Allow_StepCompensate() && m_oLadderTradeManager.IsStepCompensate(nCommand))
{
m_oLadderTradeManager.OpenStepOrder(nCommand);
}
}
m_oLiveOrderManager.DoManagement(ENUM_ORDERS_INVESTIGATE_ALL);
}
}
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool EA_MA_TradeManagement::IsMustRest_CauseBigLoss()
{
if(m_nHoursRest_WhenBigLoss <= 0)
return false;
return IsMustNowRest_CauseBigLoss(m_nHoursRest_WhenBigLoss,BalanceRiskVolume,m_fLoss_RiskBalance_Ratio_Rest);
}
//+------------------------------------------------------------------+
bool EA_MA_TradeManagement::DetermineOpenAllowance(int nOrderState)
{
if(IsMustRest_CauseBigLoss())
{
return false;
}
if(!TimeManager_AllowOpen(m_nTimeTradeManager))
{
return false;
}
return true;
}
//+------------------------------------------------------------------+
bool EA_MA_TradeManagement::CheckAngle_Stop(int nCommand, double fSL_Origin)
{
datetime nCurrentTime = iTime(m_strSymbol,m_nTimeFrame,0);
double fAngle = m_oChartCharacter.GetSlope(
(long)m_oIndicatorsInterface.m_oMVCrossDis.GetDate_CrossOver(),
m_oIndicatorsInterface.m_oMVCrossDis.GetPrice_CrossOver(),
(long)nCurrentTime,
fSL_Origin);
if(m_nMaxSlope_Stop_Distance>0 )
{
if(fAngle>90) fAngle = 360 - fAngle;
Print("CheckAngle_Stop :" , MathAbs(fAngle));
if(MathAbs(fAngle)>m_nMaxSlope_Stop_Distance)
return false;
}
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool EA_MA_TradeManagement::CheckAngle_Order(int nCommand, double fOpenPrice)
{
datetime lCurrentTime = iTime(m_strSymbol,m_nTimeFrame,0);
double fAngle = m_oChartCharacter.GetSlope(
m_oIndicatorsInterface.m_oMVCrossDis.GetDate_CrossOver(),
m_oIndicatorsInterface.m_oMVCrossDis.GetPrice_CrossOver(),
lCurrentTime,
fOpenPrice);
if(m_nMaxSlope_45_Distance >0)
{
if(fAngle>90) fAngle = 360 - fAngle;
Print("CheckAngle_Order :" , MathAbs(fAngle));
fAngle = MathAbs(fAngle)-45;
if(MathAbs(fAngle)>m_nMaxSlope_45_Distance)
return false;
}
return true;
}
//+------------------------------------------------------------------+
Reference in a new issue Copy permalink