//+------------------------------------------------------------------+
//|                                                   AMX-USDJPY.mq4 |
//|                                      Copyright 2021, TNK.Co.,Ltd.|
//|                                      https://note.com/tnk_system |
//+------------------------------------------------------------------+
#property copyright "Copyright 2021, TNK / TNK_SYSTEM"
//#property link      "https://note.com/tnk_system"
//#property version   "4.7" //連続エントリー防止
                            //複利機能に残高+クレジット方式追加
                            //MT4時間1:00の約定制限調整
                            //チャートコメントのマジックナンバー記載拡大
                            //バックテスト更新
                    //"4.8" //チャート表示コメント微調整
                            //チャートにトレードラインと獲得pips、合計獲得pips表示
                    //"4.9" //マジックナンバー重複アラート
                    //"5.0" //オートスプレッド
                            //スプレッド計測機能
                            //チャート右下にスプレッド情報表示
                            //チャートコメント整理
                    //"5.2" //プロフィットファクター表示 
                            //チャートセンターにシンボル表示
                            //チャート上部に状態表示
                    //"5.4" //チャート自動セット不具合修正
                            //チャート自動セット後、状態変化時カラー以外変更できるように修正
                            //チャートコメント複利ロット、SL変えた際に反映されないのを修正
                            //ビジュアルモード切替ボタン（EA名部）
                            //ビジュアルモードバックテスト終了時のトレード線・獲得pipsが消えるのを修正
                            //チャートコメントにRRR・勝率・トレード数追加
                            //証拠金不足チェックの不具合改善
                    //"5.5" //チャートコメントのボタンを小さく変更
                            //状態表示を英語表記に（文字化け防止）
                            //チャートコメントでオーダーコメント表示
                    //"5.6" //チャートコメントなど、解像度による間隔自動調整
                            //状態表示ON/OFFボタン削除
                            
//#property icon        "TNKIcon.ico" // アイコン取り込み
#property description "通貨ペア : USDJPY"
#property description "時間足 : H1"
#property description "スタイル : アノマリー"
#property description "ポジション数 : 1"
#property description "両建て : 無し    トレール : 無し"
#property description "TP／SL : 変更可"
#property description "週末持ち越し : 無し"
#property description "12/23~1/3 : 新規エントリー無し・決済のみ実行"
#property description "口座 : 日足5本（GMT冬+2/夏+3）専用"

#property strict
#include <stdlib.mqh>

//+------------------------------------------------------------------+
//| ユーザー入力用パラメーター                                       |
//+------------------------------------------------------------------+
input int      MagicNumber          = 8691307;   // マジックナンバー（他EAと重複不可）
input double   Lots                 = 0.01;       // ロット（単利運用時）
input double   MM_Risk              = 1.0;       // リスク％（複利選択項目の何%か）
enum  MM_Select{
      Fixed, // 0：単利/固定
      FreeMargin, // 1：複利/余剰証拠金
      Balance, // 2：複利/残高
      AddCredit,  // 3：複利/残高+クレジット
      };
input MM_Select MM_ON               = Fixed;     // 複利機能（0:固定/1:余剰証拠金/2:残高/3:残高+クレジット）
enum     Summertime_Select{
               None, // 0：none/無し
               US, // 1：US/米国式
               UK, // 2：UK/英国式
               };
input Summertime_Select Summertime  = 1;         // サマータイム（0:無し/1:米/2:英）
 double   MaxSpread_pips       = 5.5;       // 許容スプレッド（Pips）
input double   AllowSpread          = 5.5;       // 許容スプレッドPips（0:自動）
input int      Slippage             = 35;        // 許容スリッページ（Point）
 int      GMT                  = 2;         // GMT（冬時間）
input string   _Comment             = "32854:AMX-USDJPY_H1_5.6"; // 通知用コメント
input string   inputString_buy      = "8,9,10,13,14,15,18,19,20,22,23,24,25,26,27,28,29,30,31"; // 日付制御/買い（8~10,13~15,18~20,22~31日の範囲で有効）
input string   inputString_sell     = "3,4,5,8,9,10,13,14,15,18,19,20,23,24,25,26,27,28,29,30"; // 日付制御/売り（3~5,8~10,13~15,18~20,23~30日の範囲で有効）
 bool     Measurement          = false; // 計測ログcsv作成（実行スプレッド・スリッページ等）

//+------------------------------------------------------------------+
//| 内部設定・グローバル関数                                         |
//+------------------------------------------------------------------+
int      Maxposition                = 1;         // 最大ポジション
double   Gap_Pips                   = 5.0;       // 1本前ローソク足終値と現在価格の差pips
double   Gap_Pips_1                 = 6.0;       // 1本前ローソク足終値と現在価格の差pips（1:00）
bool     YearendClose               = true;      // 12/23~1/3クローズ
int      TakeProfit_pips            = 130;       // 利確指値（Pips）
int      StopLoss_pips              = 90;        // 損切逆指値（Pips）
int      MaxTakeprofit_pips         = 100;       // 最大利確指値（pips）
int      MaxStopLoss_pips           = 90;        // 最大損切り逆指値（pips）

//バーカウント・桁合わせ用
int      xBars=0, xxBars=0;
double   xpoint;
int      xTime, xxTime, xxxTime, yTime;

//エントリー時間（サーバー時間）
bool     GMT_Kadou_OK_Buy1_1        = false;     // エントリー時間（買い）
bool     GMT_Kadou_OK_Buy1_2        = false;     // エントリー時間（買い）
bool     GMT_Kadou_OK_Buy2          = false;     // エントリー時間（買い）
bool     GMT_Kadou_OK_Sell1         = false;     // エントリー時間（売り）
bool     GMT_Kadou_OK_Sell2         = false;     // エントリー時間（売り）

//ポジション決済（サーバー時間）
bool     PositionClose_Buy1         = false;     // ポジション決済（買い）
bool     PositionClose_Buy2         = false;     // ポジション決済（買い）
bool     PositionClose_Sell1        = false;     // ポジション決済（売り）
bool     PositionClose_Sell2        = false;     // ポジション決済（売り）

//バックテスト用モード切替
 bool     Development               = false;     // 開発モードON/OFF（OnTester欄にRF表示、インジケータ表示）


//+------------------------------------------------------------------+
//| 便利機能系                                                       |
//+------------------------------------------------------------------+
//チャートセット固定用
string   SYMBOL1                    = "USDJPY";  // シンボル名（頭6文字）
int      Chart_TimeFrame            = PERIOD_H1; // タイムフレーム

// EAの状態を表示
bool Pass = true;
int CT = 0;
int ChartWarning;

// チャートにトレード履歴表示用
 double  tes                          = 0.0;           // 外付け手数料(PIPS換算)
int sf, tof;
datetime hf;
double totalpips = 0, ProfitFactor = 0;
double plus_profit = 0, minus_profit = 0;
double minus_count = 0, plus_count = 0;
double RRR, WinPer;
double TradeCounts;

// マジックナンバー重複セットアラート
static bool	 check_duplicate        = true;
static const string kEA_NAME        = (string)MagicNumber;

// スプレッド計測用
double MeasureSpread, SpreadMin = 1000, SpreadMax = 0, SpreadSum = 0, SpreadAve = 0;
double SpreadMin1 = 100, SpreadMax1 = 0, SpreadSum1 = 0, SpreadAve1 = 0;
int    TickCount = 0, TickCount1 = 0, lastBars;

// オートスプレッド用
double   Adjustspread               = 5.0;       // 平均スプレッド加算用宣言
double   AllowMaxSpread             = 8.0;       // 自動最大許容スプレッド
double   Adjustspread_Margin        = 2.0;       // 自動スプレッド調整幅
double   Adjustspread_Margin1       = 1.0;       // 自動スプレッド調整幅（1:00）

// 証拠金チェック
int aCmd = 0;

// DPI換算
double DPIAdjust;

// 各計測用パラメータ
int      err, fp;
string   filename;
double   OSpread, CSpread;
uint     StartOrderTimestamp, OrderCloseTimestamp;
double   Order_Price, Close_Price;
double   Open_Yakujyou_Price, Close_Yakujou_Price;
double   Open_Spread, Close_Spread;
double   Open_Slippage, Close_Slippage;
uint     OpenLatency, CloseLatency;
double   profitpips;
string   Timeframe = (Period() == 1? "M1": Period() == 5? "M5": Period() == 15? "M15": Period() == 30? "M30":
         Period() == 60? "H1": Period() == 240? "H4": Period() == 1440? "D1": Period() == 10080? "W1": "MN1");
string   Open_Type, Close_Type;
datetime OrderCloseTime_bak = 0, OrderOpenTime_bak = 0;

//+------------------------------------------------------------------+
//| ロジック別パラメーター                                           |
//+------------------------------------------------------------------+
input string Logic_Buy1_Parameters  = "■■■■■買い1パラメータ■■■■■"; // ロジック買い1
input bool   Logic_Buy1             = true;       // 【買い1】稼働スイッチ

//エントリー
int        StartDay_Buy1            = 22;         // 【買い1｜エントリー】開始日
int        TimeOpen_Buy1            = 9;          // 【買い1｜エントリー】時刻

//決済
int        TimeClose_Buy1           = 18;         // 【買い1｜決済】時刻
input bool Modify_Buy1              = false;      // 【買い1】トレール
input int  TakeProfit_pips_Buy1     = 90;         // 【買い1】利確指値（Pips）
input int  StopLoss_pips_Buy1       = 90;         // 【買い1】損切逆指値（Pips）

//フィルター
int        MA_PERIOD                = 100;        // 【買い1｜フィルター】MA期間
int        CandleCheckCount1        = 40;         // 【買い1｜フィルター】ボラティリティフィルター/ローソク足本数
int        HL_margin1               = 30;         // 【買い1｜フィルター】ボラティリティフィルター/高安値幅（pips）
int        CandleCheckCount_H       = 20;         // 【買い1｜フィルター】ボラティリティフィルター/ローソク足本数
int        HC_margin                = 50;         // 【買い1｜フィルター】ボラティリティフィルター/高値終値の幅（pips）

//+------------------------------------------------------------------+
input string Logic_Buy2_Parameters  = "■■■■■買い2パラメータ■■■■■"; // ロジック買い2
input bool   Logic_Buy2             = true;       // 【買い2】稼働スイッチ

//エントリー
 int      TimeOpen_Buy2             = 1;          // 【買い2｜エントリー】時刻

//決済
 int      TimeClose_Buy2            = 3;          // 【買い2｜決済】時刻
input int TakeProfit_pips_Buy2      = 40;         // 【買い2】利確指値（Pips）
input int StopLoss_pips_Buy2        = 80;         // 【買い2】損切逆指値（Pips）

//フィルター
 int      CandleCheckCount_H2       = 8;          // 【買い1｜フィルター】ボラティリティフィルター/ローソク足本数
 int      HC_margin2                = 30;         // 【買い1｜フィルター】ボラティリティフィルター/高値終値の幅（pips）
 ENUM_TIMEFRAMES Dem_TF2            = PERIOD_M15; // 【買い2｜フィルター】Demarkerタイムフレーム2
 int      Dem_PERIOD2               = 9;          // 【買い2｜フィルター】Demarker期間2
 double   Dem_Limit2                = 0.63;       // 【買い2｜フィルター】Demarker限界値2
 
//+------------------------------------------------------------------+
input string Logic_Sell1_Parameters = "■■■■■売り1パラメータ■■■■■"; // ロジック売り1
input bool   Logic_Sell1            = true;       // 【売り1】稼働スイッチ

//エントリー
 int      StartDay_Sell1            = 23;         // 【売り1｜エントリー】開始日
 int      EndDay_Sell1              = 30;         // 【売り1｜エントリー】終了日
 int      TimeOpen_Sell1            = 1;          // 【売り1｜エントリー】時刻

//決済
 int      TimeClose_Sell1           = 8;          // 【売り1｜決済】時刻
input int TakeProfit_pips_Sell1     = 100;        // 【売り1】利確指値（Pips）
input int StopLoss_pips_Sell1       = 80;         // 【売り1】損切逆指値（Pips）

//フィルター
 ENUM_TIMEFRAMES ADX_TF_Sell1       = PERIOD_D1;  // 【売り1｜フィルター】ADXタイムフレーム1
 int      ADX1_Sell_Value1          = 19;         // 【売り1｜フィルター】ADX限界値1
 int      ADXx_sell_count1          = 7;          // 【売り1｜フィルター】ADX本数1

//+------------------------------------------------------------------+
input string Logic_Sell2_Parameters = "■■■■■売り2パラメータ■■■■■"; // ロジック売り2
input bool   Logic_Sell2            = true;       // 【売り2】稼働スイッチ

//エントリー
 int      TimeOpen_Sell2            = 3;          // 【売り2｜エントリー】時刻

//決済
 int      TimeClose_Sell2           = 7;          // 【売り2｜決済】時刻
input int TakeProfit_pips_Sell2     = 15;         // 【売り2】利確指値（Pips）
input int StopLoss_pips_Sell2       = 30;         // 【売り2】損切逆指値（Pips）

//フィルター
 ENUM_TIMEFRAMES ADX_TF_Sell2       = PERIOD_W1;  // 【売り2｜フィルター】ADXタイムフレーム2
 int      ADX1_Sell_Value2          = 30;         // 【売り2｜フィルター】ADX限界値2
 int      ADXx_sell_count2          = 1;          // 【売り2｜フィルター】ADX本数2
 ENUM_TIMEFRAMES ADX_TF_Sell3       = PERIOD_H1;  // 【売り2｜フィルター】ADXタイムフレーム3
 int      ADX1_Sell_Value3          = 15;         // 【売り2｜フィルター】ADX限界値3
 int      ADXx_sell_count3          = 18;         // 【売り2｜フィルター】ADX本数3
 ENUM_TIMEFRAMES Dem_TF1            = PERIOD_H4;  // 【売り2｜フィルター】Demarkerタイムフレーム1
 int      Dem_PERIOD1               = 14;         // 【売り2｜フィルター】Demarker期間1
 double   Dem_Limit1                = 0.7;        // 【売り2｜フィルター】Demarker限界値1

//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| tester function                                                  |
//+------------------------------------------------------------------+
double OnTester()
{
    // 開発モードON時、OnTesterに表示【リカバリーファクター｜勝率】
    if (Development)
    {
       // リカバリーファクター
       return(NormalizeDouble(TesterStatistics(STAT_PROFIT) / TesterStatistics(STAT_EQUITY_DD), 2));
       // 勝率
       // return(NormalizeDouble(100*TesterStatistics(STAT_PROFIT_TRADES) / TesterStatistics(STAT_TRADES), 2));
    }
    
    return(0);
}
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
{
//+------------------------------------------------------------------+
// 小数点以下の桁数に応じてPipsの値を調整する
   xpoint = Point();
   if (StringSubstr(Symbol(), 0, 6) == "XAUUSD" || StringSubstr(Symbol(), 0, 4) == "GOLD") // ゴールド用
   {
      if (Digits() == 2)
      {
         xpoint = xpoint * 10;
      }
      else if (Digits() == 3)
      {
         xpoint = xpoint * 100;
      }
   }
   else if (!(StringSubstr(Symbol(), 0, 6) == "XAUUSD" || StringSubstr(Symbol(), 0, 4) == "GOLD")) // ゴールド以外用
   {
      if (Digits() == 3 || Digits() == 5)
      {
         xpoint = xpoint * 10;
      }
   }
//+-----------------------------------------------------------------+
// 最大SL算出（コメント・複利の計算で使用）
   MaxStopLoss_pips = MathMax(Logic_Buy1? StopLoss_pips_Buy1 : 0, 
                      MathMax(Logic_Buy2? StopLoss_pips_Buy2 : 0,
                      MathMax(Logic_Sell1? StopLoss_pips_Sell1 : 0, Logic_Sell2? StopLoss_pips_Sell2 : 0)));
//+------------------------------------------------------------------+
// 開発モード（販売時はfalseに）
   if (Development) HideTestIndicators(false);// 使用しているインジケータを表示する
   else HideTestIndicators(true);// 使用しているインジケータを非表示にする
//+------------------------------------------------------------------+
// DPI換算
   double USERdpi = TerminalInfoInteger(TERMINAL_SCREEN_DPI);
   double DevPCdpi = 144;
   DPIAdjust = USERdpi / DevPCdpi;
//+------------------------------------------------------------------+
// 初期化スプレッド（バックテスト時または手動時、それ以外や自動）
   if (IsTesting() || AllowSpread != 0) MaxSpread_pips = AllowSpread;
   if (AllowSpread == 0) MaxSpread_pips = AllowMaxSpread;
//+------------------------------------------------------------------+
// チャート自動変更・シンボル・チャートコメント・EA名・状態表示
   if (!IsTesting()) 
   {
      ChartSet(); // チャート自動変更
      CenterSymbol(); // 中央のシンボル
      ChartComment(); // チャートコメント
      EA_test(); // 状態表示
      EventSetTimer(60); // 状態表示
   }
//+------------------------------------------------------------------+ 
// トレード履歴をチャートに表示（ライン・pips）
      history();
      PosHis();
//+------------------------------------------------------------------+
// マジックナンバー重複セットアラート
if (check_duplicate)
{
	double term_global_var;
	if (GlobalVariableGet(kEA_NAME, term_global_var)) 
	{
		Alert("Magic numbers are duplicated" +"\n"+ "マジックナンバー重複");
	}

	const datetime mutex_time = GlobalVariableSet(kEA_NAME, 1.0);
	if (mutex_time == 0)
	{
		const int errcode = GetLastError();
		Print("GlobalVariableSet: ERRCODE[", errcode, "]:", ErrorDescription(errcode));
	}
}
//+------------------------------------------------------------------+
// ファイル出力初期化処理
   //if (Measurement) FileInit();
//+------------------------------------------------------------------+
   
   return(0);
}

//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
   if (!IsTesting())
   {
      ObjectsDeleteAll();
      ChartSetInteger(0,CHART_COLOR_CHART_UP,clrLime);
      ChartSetInteger(0,CHART_COLOR_CHART_DOWN,clrLime);
      ChartSetInteger(0,CHART_COLOR_CHART_LINE,clrLime);
      Comment("");
   }
   
   // マジックナンバー重複用
   if (check_duplicate)
   {
		if (!GlobalVariableDel(kEA_NAME))
		{
			const int errcode = GetLastError();
			Print("GlobalVariableDel: ERRCODE[", errcode, "]:", ErrorDescription(errcode));
		}
	}
	
	// 状態表示
	EventKillTimer();
   ObjectDelete("EA_label");
}
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
{
//+------------------------------------------------------------------+
   // サマータイム調整・時間制御
   GetSummertimeShift();
   
   // ポジションをクローズ
   PositionClose();
   
   // トレーリング
   Trailing();
   
   // ポジションのエントリー
   PositionOpen();
   
   // TP, SLの再設定
   SetTPSL();
//+------------------------------------------------------------------+
// チャートコメント表示
   if (!IsTesting())
   {
      CenterSymbol(); // センターにシンボル情報
      ChartComment(); // チャートコメント
      CT++; // EA状態
      EA_test(); // EA状態
   }   
//+------------------------------------------------------------------+
// チャートにトレード線とpips表示
   if (!IsTesting() || IsVisualMode())
   {
      if (sf != Seconds() && OrdersTotal() > 0)
      {
         PosHis();
         sf = Seconds();
      }
      
      if ((hf != iTime((string)0, 60, 0) && Seconds() > 30) || tof != OrdersHistoryTotal())
      {
         history();
         hf = iTime((string)0, 60, 0);
         tof = OrdersHistoryTotal();
      }
   }
//+------------------------------------------------------------------+ 
//スプレッド値取得
   if (!IsTesting() && AllowSpread == 0)
   {
      MeasureSpread = MarketInfo(Symbol(),MODE_SPREAD) / 10;
      MeasureSP(); // スプレッド計測
      //PipsObject(); //スプレッド表示
   }
//+------------------------------------------------------------------+
// 決済がTP/SLなら情報取得
   //if (Measurement) ClosedTradeTPSL();
//+------------------------------------------------------------------+

}
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| 補正関数                                                         |
//+------------------------------------------------------------------+
void GetSummertimeShift()
{
   int MON, SUN_day, xGMT;
   int summertime_shift = 0;
   datetime gmtadjusted;

      // GMT+9を基準に、どれだけずれているかを算出する------------------------
      MON = TimeMonth(TimeCurrent()); // 何月？
      SUN_day = TimeDay(TimeCurrent()) - TimeDayOfWeek(TimeCurrent()); // その週の日曜日は何日？
      
      if (Summertime == 2) // 英国式の場合
      {
         if ((MON == 3 && SUN_day >= 25) || (MON >= 4 && MON <= 9) || (MON == 10 && SUN_day <= 24))
         //3月で、その週の日曜日が25日以上/4月～9月/10月で、その週の日曜日が23日以下
         {
            summertime_shift = 1;
         }
         else
         {
            summertime_shift = 0;
         }
      }
      else if (Summertime == 1) // 米国式の場合
      {
         if ((MON == 3 && SUN_day >= 8) || (MON >= 4 && MON <= 10) || (MON == 11 && SUN_day <= 0))
         //3月で、その週の日曜日が8日以上/4月～10月/11月で、その週の日曜日が存在しない
         {
            summertime_shift = 1;
         }
         else
         {
            summertime_shift = 0;
         }
      }
      else // サマータイム無しの場合
      {
         summertime_shift = 0;
      }
      
      xGMT = GMT - 9 + summertime_shift;//GMT+9を基準に
      //GMT+9基準でどれだけずれているかを算出する（ココマデ）--------------------

//+------------------------------------------------------------------+
//| 時間制御                                                         |
//+------------------------------------------------------------------+      
      //---- トレード許可時間の判定 ----
      xTime = TimeHour(TimeCurrent()) - xGMT; // 日本時間（サマータイム計算あり）
      xxTime = TimeHour(TimeCurrent()) - (GMT -2); // サーバー時間（サマータイム計算なし）
      xxxTime = TimeHour(TimeCurrent()) - (GMT - 2 + summertime_shift); // サーバー時間（サマータイム計算あり）
      gmtadjusted = TimeCurrent() - 60 * 60 * xGMT;
      
      // 日本時間（サマータイム計算あり）
      if (xTime < 0)
      {
         xTime = xTime + 24;
      }
      else if (xTime > 23)
      {
         xTime = xTime - 24;
      }
      
      // サーバー時間（サマータイム計算なし）
      if (xxTime < 0)
      {
         xxTime = xxTime + 24;
      }
      else if (xxTime > 23)
      {
         xxTime = xxTime - 24;
      }
      
      // サーバー時間（サマータイムあり）
      if (xxxTime < 0)
      {
         xxxTime = xxxTime + 24;
      }
      else if (xxxTime > 23)
      {
         xxxTime = xxxTime - 24;
      }
    
//+------------------------------------------------------------------+   
// ロジックBuy1
   if (Logic_Buy1 == true)
   {  
      // ポジションクローズ時間（買い_サーバー時間）
      if (xxTime >= TimeClose_Buy1
      && Day() >= 22 && Day() <= 31
      )
      {
         PositionClose_Buy1 = true;
      }
      else
      {
         PositionClose_Buy1 = false;
      }
      // エントリー時間(買い_サーバー時間）
      if (((Day() >= StartDay_Buy1 && Day() <= 24) || Day() == 31) // 日付条件
         && TimeDayOfWeek(TimeCurrent()) != 1 // 曜日条件
         && xxTime == TimeOpen_Buy1) // 時間条件
      {
         TakeProfit_pips = TakeProfit_pips_Buy1;
         StopLoss_pips = StopLoss_pips_Buy1;
         GMT_Kadou_OK_Buy1_1 = true;
      }
      else
      {
         GMT_Kadou_OK_Buy1_1 = false;
      }
      // エントリー時間フィルターなし用(買い_サーバー時間）
      if (Day() >= 25 && Day() <= 30 // 日付条件
         && xxTime == TimeOpen_Buy1) // 時間条件
      {
         TakeProfit_pips = TakeProfit_pips_Buy1;
         StopLoss_pips = StopLoss_pips_Buy1;
         GMT_Kadou_OK_Buy1_2 = true;
      }
      else
      {
         GMT_Kadou_OK_Buy1_2 = false;
      }
   }

//+------------------------------------------------------------------+
// ロジックBuy2
   if (Logic_Buy2 == true)
   {
      // ポジションクローズ時間（サーバー時間）
      if (xxxTime >= TimeClose_Buy2
      && (/*Day() == 5 ||*/ Day() == 10 || Day() == 15 || Day() == 20
         || (TimeDayOfWeek(TimeCurrent()) == 5 && ( //Day() == 3 || Day() == 4 
                                               Day() == 8 || Day() == 9 
                                              || Day() == 13 || Day() == 14
                                              || Day() == 18 || Day() == 19 
                                              //|| Day() == 23 || Day() == 24 
                                              //|| Day() == 28 || Day() == 29
                                               )
            )
         )
      )
      {
         PositionClose_Buy2 = true;
      }
      else
      {
         PositionClose_Buy2 = false;
      }
      // エントリー時間(サーバー時間）
      if (xxTime == TimeOpen_Buy2
      )
      {
         TakeProfit_pips = TakeProfit_pips_Buy2;
         StopLoss_pips = StopLoss_pips_Buy2;
         GMT_Kadou_OK_Buy2 = true;
      }
      else
      {
         GMT_Kadou_OK_Buy2 = false;
      }
   }

//+------------------------------------------------------------------+
// ロジックSell1
   if (Logic_Sell1 == true)
   {
      // ポジションクローズ時間（サーバー時間）
      if (xxTime >= TimeClose_Sell1
      && (Day() >= StartDay_Sell1 && Day() <= EndDay_Sell1)
      )
      {
         PositionClose_Sell1 = true;
      }
      else
      {
         PositionClose_Sell1 = false;
      }
      // エントリー時間(サーバー時間）
      if (xxxTime == TimeOpen_Sell1
      && (Day() >= StartDay_Sell1 && Day() <= EndDay_Sell1)
      )
      {
         TakeProfit_pips = TakeProfit_pips_Sell1;
         StopLoss_pips = StopLoss_pips_Sell1;
         GMT_Kadou_OK_Sell1 = true;
      }
      else
      {
         GMT_Kadou_OK_Sell1 = false;
      }
   }

//+------------------------------------------------------------------+
// ロジックSell2
   if (Logic_Sell2 == true)
   {
      // ポジションクローズ時間（サーバー時間）
      if (xxxTime >= TimeClose_Sell2
      && (Day() == 5 || Day() == 10 || Day() == 15 || Day() == 20
         || (TimeDayOfWeek(TimeCurrent()) == 5 && ( Day() == 3 || Day() == 4 
                                           || Day() == 8 || Day() == 9 
                                           || Day() == 13 || Day() == 14
                                           || Day() == 18 || Day() == 19 
                                           //|| Day() == 23 || Day() == 24 
                                           //|| Day() == 28 || Day() == 29
                                            )
            )
         )
      )
      {
         PositionClose_Sell2 = true;
      }
      else
      {
         PositionClose_Sell2 = false;
      }
      // エントリー時間(サーバー時間）
      if (xxxTime == TimeOpen_Sell2
      )
      {
         TakeProfit_pips = TakeProfit_pips_Sell2;
         StopLoss_pips = StopLoss_pips_Sell2;
         GMT_Kadou_OK_Sell2 = true;
      }
      else
      {
         GMT_Kadou_OK_Sell2 = false;
      }
   }

//+------------------------------------------------------------------+
      // ここまで、エグジットとトレーリングは、取引時間に関係なく実施する
      //---- トレード許可時間の判定（ココマデ） ----
}
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| ポジションのクローズ                                             |
//+------------------------------------------------------------------+
void PositionClose()
{
   int i;
   bool res;
         
   // 始値から指定ティックのみ判定
   if(Volume[0] <= 20) // 20ティック目まで判定
   {
      // 所有しているポジションをクローズする
      for(i=OrdersTotal()-1; i>=0; i--)
      {
         //オーダー選択(エラーを生じた場合、ループから抜け出す)
         if (OrderSelect( i, SELECT_BY_POS, MODE_TRADES ) == false)
         {
            Print("OrderSelect returned the error of ", GetLastError() );
            break;
         }
         
         //オーダー確認（通貨ペアが一致しない場合は、for文の先頭に戻る）
         if (OrderSymbol() != Symbol()) continue;
         
         //マジックナンバー確認（マジックナンバーが一致しない場合は、for文の先頭に戻る）
         if (OrderMagicNumber() != MagicNumber) continue;
         
         //エントリーからのローソク足本数が1本未満なら、for文の先頭に戻る）
         int OrderOpenCandleCount = iBarShift(NULL, 0, OrderOpenTime());
         if (OrderOpenCandleCount == 0) continue;

         if (OrderType() == OP_BUY)
         {
            if (Exit2(false) == 2)
            {
               //CSpread = Ask - Bid; // スプレッド計測
               //OrderCloseTimestamp = GetTickCount();// レイテンシー計測
               //Close_Price = Bid; // 決済売り注文を入れる価格
               res = OrderClose(OrderTicket(), OrderLots(), Bid, NULL, Green);
               
               /*if (res == true && Measurement == true)
               {
                  CloseLatency = GetTickCount() - OrderCloseTimestamp; // レイテンシー計測
                                                      
                  if(OrderSelect(OrdersHistoryTotal()-1,SELECT_BY_POS,MODE_HISTORY)==false) // 履歴を選択
                  { 
                     Print("Access to history failed with error (",GetLastError(),")"); 
                     return; 
                  }
                  // オーダー確認（通貨ペアとマジックナンバーが一致した場合は、次の処理へ進む
                  if (OrderSymbol() == Symbol() && OrderMagicNumber() == MagicNumber)
                  {   
                     CloseTradeInfo();
                  }
               }*/
            }
         }

         if (OrderType() == OP_SELL)
         {
            if (Exit1(true) == 1)
            {
               //CSpread = Ask - Bid; //スプレッド計測
               //OrderCloseTimestamp = GetTickCount(); // レイテンシー計測
               //Close_Price = Ask; // 決済買い注文を入れる価格
               res = OrderClose(OrderTicket(), OrderLots(), Ask, NULL, Green);
               
               /*if (res == true && Measurement == true)
               {
                  CloseLatency = GetTickCount() - OrderCloseTimestamp; // レイテンシー計測

                  if(OrderSelect(OrdersHistoryTotal()-1,SELECT_BY_POS,MODE_HISTORY)==false) // 履歴を選択
                  { 
                     Print("Access to history failed with error (",GetLastError(),")"); 
                     return; 
                  }
                  // オーダー確認（通貨ペアとマジックナンバーが一致した場合は、次の処理へ進む
                  if (OrderSymbol() == Symbol() && OrderMagicNumber() == MagicNumber)
                  {   
                     CloseTradeInfo();
                  }
               }*/
            }
         }
      } // 所有しているポジションをクローズする（ココマデ）
   } // 始値から指定ティックのみ判定（ココマデ）
}
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| トレーリング                                                     |
//+------------------------------------------------------------------+
void Trailing()
{
   int i;
   bool res;
   double StopLevel = MarketInfo(Symbol(),MODE_STOPLEVEL) * (xpoint / 10);
   
   // 始値から指定ティックのみ判定
   if (Volume[0] <= 20)
   {

      // 所有しているポジションのストップをトレールする
      for (i=OrdersTotal()-1; i>=0; i--)
      {
         //オーダー選択(エラーを生じた場合、ループから抜け出す)
         if (OrderSelect( i, SELECT_BY_POS, MODE_TRADES ) == false)
         {
            Print("OrderSelect returned the error of ", GetLastError() );
            break;
         }
         
         //オーダー確認（通貨ペアが一致しない場合は、for文の先頭に戻る）
         if (OrderSymbol() != Symbol()) continue;
         
         //マジックナンバー確認（マジックナンバーが一致しない場合は、for文の先頭に戻る）
         if (OrderMagicNumber() != MagicNumber) continue;
         
         if (OrderType() == OP_BUY)
         {
            double SL_buy = NormalizeDouble(Open[0] - StopLoss_pips_Buy1 * xpoint, Digits);
            
            // トレイルON、OFF
            if (Modify_Buy1 == true)
            {
               // ロジックBuy1
               if (xxTime >= TimeOpen_Buy1 && xxTime <= TimeClose_Buy1
               && Bid - StopLevel >= SL_buy
               && OrderStopLoss() < SL_buy
               )
               {
                  res = OrderModify(OrderTicket(), 
                                    OrderOpenPrice(), 
                                    SL_buy,
                                    OrderTakeProfit(),
                                    0,
                                    MediumSeaGreen);
               }
            }
         }
      } // 所有しているポジションのストップをトレールする（ココマデ）
   } // 始値から指定ティックのみ判定（ココマデ）
}
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| ポジションのオープン                                             |
//+------------------------------------------------------------------+
void PositionOpen()
{
   int i, j;
   int ticket;
   int CountBuy = 0,CountSell = 0;
   bool res;
   int OrderOpen_BarCount_buy = 1; // 0にすると、履歴無いときにエントリーしないため、他の値を初期値にする
   int OrderOpen_BarCount_sell = 1;
   int OrderClose_BarCount_buy = 1; // 0にすると、履歴無いときにエントリーしないため、他の値を初期値にする
   int OrderClose_BarCount_sell = 1;
   
   // 始値から指定ティックのみ判定
   if(Volume[0] <= 20 || (xxTime == 1 && Volume[0] <= 200)) // 20（1時台は200）ティック目まで判定
   {
      // ポジションの数をカウントする
      for(i=OrdersTotal()-1; i>=0; i--)
      {
         //オーダー選択(エラーを生じた場合、ループから抜け出す)
         if (OrderSelect( i, SELECT_BY_POS, MODE_TRADES ) == false)
         {
            Print("OrderSelect returned the error of ", GetLastError() );
            break;
         }
         
         //オーダー確認（通貨ペアが一致しない場合は、for文の先頭に戻る）
         if (OrderSymbol() != Symbol()) continue;
         
         //マジックナンバー確認（マジックナンバーが一致しない場合は、for文の先頭に戻る）
         if (OrderMagicNumber() != MagicNumber) continue;
   
         if (OrderType() == OP_BUY)
         {
            CountBuy = CountBuy + 1;
         }
         
         if (OrderType() == OP_SELL)
         {
            CountSell = CountSell + 1;
         }
         
         aCmd = OrderType();

      } // ポジションの数をカウントする（ココマデ）
      
      // 最終エントリー・決済からのローソク足本数をカウントする（連続エントリー防止）
      for(j=OrdersHistoryTotal()-1; j>=0; j--)
      {
         //オーダー選択(エラーを生じた場合、ループから抜け出す)
         if (OrderSelect( j, SELECT_BY_POS, MODE_HISTORY ) == false)
         {
            Print("OrderSelect returned the error of ", GetLastError() );
            break;
         }
         
         //オーダー確認（通貨ペアが一致しない場合は、for文の先頭に戻る）
         if (OrderSymbol() != Symbol()) continue;
         
         //マジックナンバー確認（マジックナンバーが一致しない場合は、for文の先頭に戻る）
         if (OrderMagicNumber() != MagicNumber) continue;
   
         //最終エントリー・決済からのローソク足本数
         if (OrderType() == OP_BUY) // 買いの場合
         {
            OrderOpen_BarCount_buy = iBarShift(NULL, 0, OrderOpenTime());
            OrderClose_BarCount_buy = iBarShift(NULL, 0, OrderCloseTime());
            if (OrderClose_BarCount_buy != -1) break; // 一度最終決済を抽出したらループから抜ける
         }
         if (OrderType() == OP_SELL) // 売りの場合
         {
            OrderOpen_BarCount_sell = iBarShift(NULL, 0, OrderOpenTime());
            OrderClose_BarCount_sell = iBarShift(NULL, 0, OrderCloseTime());
            if (OrderClose_BarCount_sell != -1) break; // 一度最終決済を抽出したらループから抜ける
         }
      } // 最終エントリー・決済からのローソク足本数をカウントする（ココマデ）

   
   // 証拠金不足・トレード許可チェック
   if (EquityCheck())
   {
      // エントリー条件を確認し、成立していればエントリーを行う  
      if (Entry(true) == 1 // 買いエントリー
         && CountSell == 0
         && CountBuy < Maxposition
         && OrderOpen_BarCount_buy + OrderClose_BarCount_buy != 0 // 直前に発注後即決済が行われていたらエントリー禁止
         )
      {
            //OSpread = Ask - Bid;// スプレッド計測
            //StartOrderTimestamp = GetTickCount();// レイテンシー計測
            //Order_Price = Ask;// 買い注文を入れる価格
            ticket = OrderSend(Symbol(), 
                               OP_BUY, 
                               CalculateLots(MM_Risk, MaxStopLoss_pips), 
                               Ask, 
                               Slippage, 
                               Ask - StopLoss_pips * xpoint, 
                               Ask + TakeProfit_pips * xpoint, 
                               _Comment, 
                               MagicNumber, 
                               0, 
                               Blue);
         // エントリーが失敗であれば、TPSLを分割して注文する
         if (ticket == -1)
         {
            ticket = OrderSend(Symbol(), 
                               OP_BUY, 
                               CalculateLots(MM_Risk, MaxStopLoss_pips), 
                               Ask, 
                               Slippage, 
                               0, 
                               0, 
                               _Comment, 
                               MagicNumber, 
                               0, 
                               Blue);
                  
            // エントリーに成功していれば、TP, SLをセットする
            if (ticket != -1)
            {
               // チケットを使ってオーダーを選択(エラーを生じた場合、何もしない)
               if( OrderSelect( ticket, SELECT_BY_TICKET ) == true )
               {
                  res = OrderModify(OrderTicket(), 
                                    OrderOpenPrice(), 
                                    OrderOpenPrice() - StopLoss_pips * xpoint,
                                    OrderOpenPrice() + TakeProfit_pips * xpoint,
                                    0, MediumSeaGreen);
               }
            }
         }
         // チケットを使ってオーダーを選択(エラーを生じた場合、何もしない)
         /*if (OrderSelect(ticket, SELECT_BY_TICKET) == true && Measurement == true)
         {
            OpenTradeInfo();
         }*/
      }
      
      if (Entry(false) == 2 // 売りエントリー
         && CountBuy == 0
         && CountSell < Maxposition
         && OrderOpen_BarCount_sell + OrderClose_BarCount_sell != 0 // 直前に発注後即決済が行われていたらエントリー禁止
         )
      {
            //OSpread = Ask - Bid;// スプレッド計測
            //StartOrderTimestamp = GetTickCount();// レイテンシー計測
            //Order_Price = Bid;// 売り注文を入れる価格
            ticket = OrderSend(Symbol(), 
                               OP_SELL, 
                               CalculateLots(MM_Risk, MaxStopLoss_pips), 
                               Bid, 
                               Slippage, 
                               Bid + StopLoss_pips * xpoint,
                               Bid - TakeProfit_pips * xpoint, 
                               _Comment, 
                               MagicNumber, 
                               0, 
                               Red);
         // エントリーが失敗であれば、TPSLを分割して注文する
         if (ticket == -1)
         {
            ticket = OrderSend(Symbol(), 
                               OP_SELL, 
                               CalculateLots(MM_Risk, MaxStopLoss_pips), 
                               Bid, 
                               Slippage, 
                               0, 
                               0, 
                               _Comment, 
                               MagicNumber, 
                               0, 
                               Red);
      
            // エントリーに成功していれば、TP, SLをセットする
            if (ticket != -1)
            {
               // チケットを使ってオーダーを選択(エラーを生じた場合、何もしない)
               if( OrderSelect( ticket, SELECT_BY_TICKET ) == true )
               {
                  res = OrderModify(OrderTicket(), 
                                    OrderOpenPrice(), 
                                    OrderOpenPrice() + StopLoss_pips * xpoint,
                                    OrderOpenPrice() - TakeProfit_pips * xpoint,
                                    0, MediumSeaGreen);
               }
            }
         }
         // チケットを使ってオーダーを選択(エラーを生じた場合、何もしない)
         /*if (OrderSelect(ticket, SELECT_BY_TICKET) == true && Measurement == true)
         {
            OpenTradeInfo();
         }*/
      }
   }
   } // 始値から指定ティックのみ判定（ココマデ）
}
//+------------------------------------------------------------------+   
bool EquityCheck()
{
// 証拠金不足・トレード許可チェック
   double usedMoney = AccountEquity() - AccountFreeMarginCheck(Symbol(), aCmd, CalculateLots(MM_Risk, StopLoss_pips));
   if (!(
      (AccountStopoutMode() == 0 && usedMoney > 0.0 && (AccountEquity() / usedMoney) * 100 <= AccountStopoutLevel())
      || (AccountStopoutMode() == 0 && usedMoney > 0.0 && AccountFreeMarginCheck(Symbol(), aCmd, CalculateLots(MM_Risk, StopLoss_pips)) <= 0)
      || (AccountStopoutMode() == 1 && AccountFreeMarginCheck(Symbol(), aCmd, CalculateLots(MM_Risk, StopLoss_pips)) <= AccountStopoutLevel())
      )
      && IsTradeAllowed() == true) // トレード許可判定
   {
      return(true);
   }
   else return(false);

}
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| TakeProfit, StopLoss                                             |
//+------------------------------------------------------------------+
void SetTPSL()
{
   int i;
   bool res;
   
   // 始値から指定ティックのみ判定
   if(Volume[0] <= 20)
   {
      // ポジションにTP, SLをセットする
      for(i=OrdersTotal()-1; i>=0; i--)
      {
         //オーダー選択(エラーを生じた場合、ループから抜け出す)
         if (OrderSelect( i, SELECT_BY_POS, MODE_TRADES ) == false)
         {
            Print("OrderSelect returned the error of ", GetLastError() );
            break;
         }
         
         //オーダー確認（通貨ペアが一致しない場合は、for文の先頭に戻る）
         if (OrderSymbol() != Symbol()) continue;
         
         //マジックナンバー確認（マジックナンバーが一致しない場合は、for文の先頭に戻る）
         if (OrderMagicNumber() != MagicNumber) continue;
   
         // 買いポジションの場合
         if (OrderType() == OP_BUY)
         {
            // TP, SLがどちらも設定されていなければ、TP, SLを設定する
            if (OrderStopLoss() == 0 && OrderTakeProfit() == 0)
            {
               res = OrderModify(OrderTicket(), OrderOpenPrice(), 
                                 OrderOpenPrice() - StopLoss_pips * xpoint,
                                 OrderOpenPrice() + TakeProfit_pips * xpoint,
                                 0, MediumSeaGreen);
            }
         }
   
         // 売りポジションの場合
         if (OrderType() == OP_SELL)
         {
            // TP, SLがどちらも設定されていなければ、TP, SLを設定する
            if (OrderStopLoss() == 0 && OrderTakeProfit() == 0)
            {
               res = OrderModify(OrderTicket(), OrderOpenPrice(), 
                                 OrderOpenPrice() + StopLoss_pips * xpoint,
                                 OrderOpenPrice() - TakeProfit_pips * xpoint,
                                 0, MediumSeaGreen);
            }
         }
      }
   }
}
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| 複利機能                                                         |
//+------------------------------------------------------------------+
// 複利機能のロット数を計算する
double CalculateLots(double risk, // 許容するリスク
                     int sl_pips) // ストップロス
{
   // バックテスト時は、バックテスト用の複利機能を使用する
   if (IsTesting())
      return(CalculateLots_forTest(risk, sl_pips));
   else
      return(CalculateLots_forReal(risk, sl_pips));
}

// 複利機能のロット数を計算する（実トレード用）
double CalculateLots_forReal(double risk, // 許容するリスク
                             int sl_pips) // ストップロス
{
   double freemargin;     // アカウントの余剰証拠金
   double balance;        // アカウントの口座残高
   double credit;         // アカウントのクレジット
   double tickvalue;      // 1ロット1pip当たりの証拠金通貨相当額
   double lotstep;        // サーバのロット数の最小刻み制限
   double maxlots;        // サーバの最大ロット数制限
   double minlots;        // サーバの最小ロット数制限
   double lotsize = Lots;        // ロットサイズ

   freemargin     = AccountFreeMargin();
   balance        = AccountBalance();
   credit         = AccountCredit();
   tickvalue      = MarketInfo(NULL, MODE_TICKVALUE);
   lotstep        = MarketInfo(NULL, MODE_LOTSTEP);
   maxlots        = MarketInfo(NULL, MODE_MAXLOT);
   minlots        = MarketInfo(NULL, MODE_MINLOT);
   
   // 複利機能を使わない場合、Lotsから修正されたlotsizeを返す
   int step = (int)MathAbs(MathLog10(MarketInfo(Symbol(), MODE_LOTSTEP)));
   lotsize = NormalizeDouble(Lots, (int)step); //ロットステップで四捨五入
   lotsize = MathMax(minlots, MathMin(maxlots, lotsize)); //最小ロット以下なら最小ロットに、最大ロット以上なら最大ロットに修正（mql5マーケットで必須）
   if (MM_ON == Fixed) return(lotsize);
   
   // tickvalueはpipsではなくpointなので、小数点以下の桁数に応じて補正する
   if (StringSubstr(Symbol(), 0, 6) == "XAUUSD" || StringSubstr(Symbol(), 0, 4) == "GOLD") // ゴールド桁合わせ
   {
      if (Digits() == 2)
         tickvalue = tickvalue * 10;
      else if (Digits() == 3)
         tickvalue = tickvalue * 100;
   }
   else if (!(StringSubstr(Symbol(), 0, 6) == "XAUUSD" || StringSubstr(Symbol(), 0, 4) == "GOLD")) // ゴールド以外桁合わせ
   {
      if (Digits() == 3 || Digits() == 5)
      tickvalue = tickvalue * 10;
   }
   
   // 許容するリスクとSLの幅から、ロットサイズを計算する。
   if (MM_ON == FreeMargin) // 余剰証拠金方式
   {
      lotsize = (freemargin * risk / 100.0) // 許容するリスク (余剰証拠金のrisk%)
              / (sl_pips * tickvalue); // 1ロットでSLにかかった時の金額
   }
   else if (MM_ON == Balance) // 残高方式
   {
      lotsize = (balance * risk / 100.0) // 許容するリスク (余剰証拠金のrisk%)
              / (sl_pips * tickvalue); // 1ロットでSLにかかった時の金額
   }
   else if (MM_ON == AddCredit) // 残高+クレジット方式
   {
      lotsize = ((balance + credit) * risk / 100.0) // 許容するリスク (余剰証拠金のrisk%)
              / (sl_pips * tickvalue); // 1ロットでSLにかかった時の金額
   }
   
   // サーバのロット数の刻みに合わせてロット数を修正
   lotsize = MathFloor(lotsize / lotstep) * lotstep;
   
   // サーバの最小ロット数・最大ロット数で補正をかける
   lotsize = MathMax(lotsize, minlots);
   lotsize = MathMin(lotsize, maxlots);

   return(lotsize);
}

// 複利機能のロット数を計算する（バックテスト用）
double CalculateLots_forTest(double risk, // 許容するリスク
                             int sl_pips) // ストップロス
{
   double freemargin;     // アカウントの余剰証拠金
   double balance;        // アカウントの口座残高
   double credit;         // アカウントのクレジット
   double tickvalue;      // 1ロット1pip当たりの証拠金通貨相当額
   double lotstep;        // サーバのロット数の最小刻み制限
   double maxlots;        // サーバの最大ロット数制限
   double minlots;        // サーバの最小ロット数制限
   double lotamount;      // 1ロットの通貨数
   double lotsize = Lots;        // ロットサイズ
   double conv;           // 口座通貨種類による補正係数

   freemargin     = AccountFreeMargin();
   balance        = AccountBalance();
   credit         = AccountCredit();
   tickvalue      = MarketInfo(NULL, MODE_TICKVALUE);
   lotstep        = MarketInfo(NULL, MODE_LOTSTEP);
   maxlots        = MarketInfo(NULL, MODE_MAXLOT);
   minlots        = MarketInfo(NULL, MODE_MINLOT);
   lotamount      = MarketInfo(NULL, MODE_LOTSIZE);
   
   // 複利機能を使わない場合、Lotsから修正されたlotsizeを返す
   int step = (int)MathAbs(MathLog10(MarketInfo(Symbol(), MODE_LOTSTEP)));
   lotsize = NormalizeDouble(Lots, step); //ロットステップで四捨五入
   lotsize = MathMax(minlots, MathMin(maxlots, lotsize)); //最小ロット以下なら最小ロットに、最大ロット以上なら最大ロットに修正（mql5マーケットで必須）
   if (MM_ON == Fixed) return(lotsize);
   
   // 1万通貨*1pips = $1 = 100円と仮定し、1ロット1pipの変動が口座通貨でいくらに相当するか計算
   // 1 lot = 10万通貨
   // 口座通貨 = JPY : tickvalue = 1000円/(lot・pip)
   // 口座通貨 = USD : tickvalue = $10/(lot・pip)
   if (StringSubstr(Symbol(), 0, 6) == "XAUUSD" || StringSubstr(Symbol(), 0, 4) == "GOLD") // ゴールド桁合わせ
   {
      conv = 1000;
      if (AccountCurrency() == "JPY")
      conv = 100000;
      tickvalue = lotamount / 10000 * conv;
   }
   else if (!(StringSubstr(Symbol(), 0, 6) == "XAUUSD" || StringSubstr(Symbol(), 0, 4) == "GOLD")) // ゴールド以外桁合わせ
   {
      conv = 1;
      if (AccountCurrency() == "JPY")
      conv = 100;
      tickvalue = lotamount / 10000 * conv;
   }

   // 許容するリスクとSLの幅から、ロットサイズを計算する。
   if (MM_ON == FreeMargin) // 余剰証拠金方式
   {
      lotsize = (freemargin * risk / 100.0) // 許容するリスク (余剰証拠金のrisk%)
              / (sl_pips * tickvalue); // 1ロットでSLにかかった時の金額
   }
   else if (MM_ON == Balance) // 残高方式
   {
      lotsize = (balance * risk / 100.0) // 許容するリスク (余剰証拠金のrisk%)
              / (sl_pips * tickvalue); // 1ロットでSLにかかった時の金額
   }
   else if (MM_ON == AddCredit) // 残高+クレジット方式
   {
      lotsize = ((balance + credit) * risk / 100.0) // 許容するリスク (余剰証拠金のrisk%)
              / (sl_pips * tickvalue); // 1ロットでSLにかかった時の金額
   }
   
   // サーバのロット数の刻みに合わせてロット数を修正
   lotsize = MathFloor(lotsize / lotstep) * lotstep;
   
   // サーバの最小ロット数・最大ロット数で補正をかける
   lotsize = MathMax(lotsize, minlots);
   lotsize = MathMin(lotsize, maxlots);

   return(lotsize);
}
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| エントリー総括                                                   |
//+------------------------------------------------------------------+
int Entry(bool isbuy)
{
   if (Entry_Rule1(isbuy) == 1 && (Entry_Filter1(isbuy) == 1 || Entry_Filter1(isbuy) == 3)
                               && (Entry_Filter2(isbuy) == 1 || Entry_Filter2(isbuy) == 3)
                               && (Entry_Filter3(isbuy) == 1 || Entry_Filter3(isbuy) == 3)
                               && (Entry_Filter4(isbuy) == 1 || Entry_Filter4(isbuy) == 3)
                               && (Entry_Filter5(isbuy) == 1 || Entry_Filter5(isbuy) == 3)
                               && (Entry_Filter6(isbuy) == 1 || Entry_Filter6(isbuy) == 3)
                               && (Entry_Filter7(isbuy) == 1 || Entry_Filter7(isbuy) == 3)
      )
   {
      return(1);
   }
   else if (Entry_Rule1(isbuy) == 2 && (Entry_Filter1(isbuy) == 2 || Entry_Filter1(isbuy) == 3)
                                    && (Entry_Filter2(isbuy) == 2 || Entry_Filter2(isbuy) == 3)
                                    && (Entry_Filter3(isbuy) == 2 || Entry_Filter3(isbuy) == 3)
                                    && (Entry_Filter4(isbuy) == 2 || Entry_Filter4(isbuy) == 3)
                                    && (Entry_Filter5(isbuy) == 2 || Entry_Filter5(isbuy) == 3)
                                    && (Entry_Filter6(isbuy) == 2 || Entry_Filter6(isbuy) == 3)
                                    && (Entry_Filter7(isbuy) == 2 || Entry_Filter7(isbuy) == 3)
      )
   {
      return(2);
   }
   else
   {
      return(0);
   }
}
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| 売りポジションの決済総括                                         |
//+------------------------------------------------------------------+
int Exit1(bool isbuy)
{
   if (Exit_Rule1(isbuy) == 3 && Exit_Rule2(isbuy) == 3 && Exit_Rule3(isbuy) == 3 
    && Exit_Rule4(isbuy) == 3 && Exit_Rule5(isbuy) == 3)
   {
      return(0);
   }
   else if (Exit_Rule1(isbuy) == 1)
   {
      return(1);
   }
   else if( Exit_Rule2(isbuy) == 1)
   {
      return(1);
   }
   else if (Exit_Rule3(isbuy) == 1)
   {
      return(1);
   }
   else if( Exit_Rule4(isbuy) == 1)
   {
      return(1);
   }
   else if (Exit_Rule5(isbuy) == 1)
   {
      return(1);
   }
   else
   {
      return(0);
   }
}
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| 買いポジションの決済総括                                         |
//+------------------------------------------------------------------+
int Exit2(bool isbuy)
{
   if (Exit_Rule1(isbuy) == 3 && Exit_Rule2(isbuy) == 3 && Exit_Rule3(isbuy) == 3 
    && Exit_Rule4(isbuy) == 3 && Exit_Rule5(isbuy) == 3)
   {
      return(0);
   }
   else if (Exit_Rule1(isbuy) == 2)
   {
      return(2);
   }
   else if (Exit_Rule2(isbuy) == 2)
   {
      return(2);
   }
   else if (Exit_Rule3(isbuy) == 2)
   {
      return(2);
   }
   else if (Exit_Rule4(isbuy) == 2)
   {
      return(2);
   }
   else if (Exit_Rule5(isbuy) == 2)
   {
      return(2);
   }
   else
   {
      return(0);
   }
}
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| エントリールール1                                                |
//+------------------------------------------------------------------+
int Entry_Rule1(bool isbuy)
{
   //エントリールール1
   // 時間制御によるエントリー可能時間でエントリー判定
   if (isbuy && (GMT_Kadou_OK_Buy1_1 || GMT_Kadou_OK_Buy1_2 || GMT_Kadou_OK_Buy2))
   {
      return(1);
   } // 買い
   
   if (!isbuy && (GMT_Kadou_OK_Sell1 || GMT_Kadou_OK_Sell2))
   {
      return(2);
   } // 売り

      return(0); // エントリー出来ない   

   //エントリールール1ココマデ
}
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| エントリーフィルター1                                            |
//+------------------------------------------------------------------+
int Entry_Filter1(bool isbuy)
{
   //エントリーフィルター1
// 固定仕様系
// スプレッドフィルター
   double spread = MarketInfo(NULL, MODE_SPREAD);
   if (StringSubstr(Symbol(), 0, 6) == "XAUUSD" || StringSubstr(Symbol(), 0, 4) == "GOLD") // ゴールド桁合わせ
   {
      if (Digits() == 2) spread /= 10.0;
      else if (Digits() == 3) spread /= 100.0;
   }
   else if (!(StringSubstr(Symbol(), 0, 6) == "XAUUSD" || StringSubstr(Symbol(), 0, 4) == "GOLD")) // ゴールド以外桁合わせ
   {
      if (Digits == 3 || Digits == 5) spread /= 10.0;
   }
   
   if (spread > MaxSpread_pips) return(0);
   
// ギャップフィルター
   double Close0 = iClose(NULL, 0, 0);
   double Close1 = iClose(NULL, 0, 1);
   if (xxTime != 1)
   {
      if (isbuy  && Close0 - Close1 >= Gap_Pips * xpoint) return(0); // (現在価格-1本足終値)が、指定pips以上で買い禁止
      if (!isbuy && Close1 - Close0 >= Gap_Pips * xpoint) return(0); // (1本足終値-現在価格)が、指定pips以上で売り禁止
   }
   if (xxTime == 1)
   {
      if (isbuy  && Close0 - Close1 >= Gap_Pips_1 * xpoint) return(0); // (現在価格-1本足終値)が、指定pips以上で買い禁止
      if (!isbuy && Close1 - Close0 >= Gap_Pips_1 * xpoint) return(0); // (1本足終値-現在価格)が、指定pips以上で売り禁止
   }
   
// 年末年始フィルター_12/23~1/3まではエントリーしない
   int NGMonth = Month();
   int NGDay = Day();
   if (YearendClose && ((NGMonth == 12 && NGDay >= 23) || (NGMonth == 1 && NGDay <= 3)))
   {
      return(0);
   }

   //エントリーフィルター1ココマデ
   return(3);
}
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| エントリーフィルター2                                            |
//+------------------------------------------------------------------+
int Entry_Filter2(bool isbuy)
{
   //エントリーフィルター2
// ユーザー側パラメータによる日付制御用フィルター
   
   int d=0;
   string outputStrings_buy[];
   int Count_buy = StringSplit(inputString_buy, ',', outputStrings_buy);
   string outputStrings_sell[];
   int Count_sell = StringSplit(inputString_sell, ',', outputStrings_sell);
   
   if (isbuy)
   {
      for(d=0; d<=Count_buy-1; d++)
      {
         if ((string)Day() == outputStrings_buy[d])
         {
            return(3);
         }
      }
   }
   
   if (!isbuy)
   {
      for(d=0; d<=Count_sell-1; d++)
      {
         if ((string)Day() == outputStrings_sell[d])
         {
            return(3);
         }
      }
   }
   
   return(0);

   //エントリーフィルター2ココマデ
   return(3);
}
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| エントリーフィルター3                                            |
//+------------------------------------------------------------------+
int Entry_Filter3(bool isbuy)
{
   //エントリーフィルター3
// ロジック買い1フィルター
if (Logic_Buy1 && isbuy && (GMT_Kadou_OK_Buy1_1 || GMT_Kadou_OK_Buy1_2))
{ 
// ボラティリティフィルター
   double MostHigh1 = High[iHighest(NULL, PERIOD_H1, MODE_HIGH, CandleCheckCount1, 1)];
   double MostLow1 = Low[iLowest(NULL, PERIOD_H1, MODE_LOW , CandleCheckCount1, 1)];
   if (NormalizeDouble(MostHigh1 - MostLow1, Digits) < HL_margin1 * xpoint) return(0);
   
   double MostHigh = High[iHighest(NULL, PERIOD_H1, MODE_HIGH, CandleCheckCount_H, 1)];
   double HC = NormalizeDouble(MostHigh - Close[1], Digits);
   if (HC > HC_margin * xpoint) return(0);

if (GMT_Kadou_OK_Buy1_1)
{
// MAフィルター
   double MA_fast1 = iMA(NULL, PERIOD_H1, MA_PERIOD, 0, MODE_EMA, PRICE_CLOSE, 1);
   MA_fast1 = NormalizeDouble(MA_fast1, Digits);
   if (Close[1] <= MA_fast1) return(0);
   
   double MA1 = iMA(NULL, PERIOD_M15, 20, 0, MODE_SMA, PRICE_CLOSE, 1);
   MA1 = NormalizeDouble(MA1, Digits);
   if (MA1 <= Close[1]) return(0);
}  
}
   //エントリーフィルター3ココマデ
   return(3);
}
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| エントリーフィルター4                                            |
//+------------------------------------------------------------------+
int Entry_Filter4(bool isbuy)
{
   //エントリーフィルター4
// ロジック買い2フィルター
if (GMT_Kadou_OK_Buy2 && isbuy)
{
// ゴトウビフィルター
   if (!(/*Day() == 5 ||*/ Day() == 10 || Day() == 15 || Day() == 20
   || (TimeDayOfWeek(TimeCurrent()) == 5 && ( //Day() == 3 || Day() == 4 
                                            Day() == 8 || Day() == 9 
                                           || Day() == 13 || Day() == 14
                                           || Day() == 18 || Day() == 19 
                                           //|| Day() == 23 || Day() == 24 
                                           //|| Day() == 28 || Day() == 29
                                            )
      )
      ))
   {
      return(0);
   }

// ボラティリティフィルター
   double MostHigh3 = High[iHighest(NULL, PERIOD_H1, MODE_HIGH, CandleCheckCount_H2, 1)];
   double HC2 = NormalizeDouble(MostHigh3 - Close[1], Digits);
   if (HC2 > HC_margin2 * xpoint) return(0);

// Demarkerフィルター   
   double Dem2 = iDeMarker(NULL, Dem_TF2, Dem_PERIOD2, 1 );
   if (Dem2 >= Dem_Limit2) return(0);
}

   //エントリーフィルター4ココマデ
   return(3);
}
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| エントリーフィルター5                                            |
//+------------------------------------------------------------------+
int Entry_Filter5(bool isbuy)
{
   //エントリーフィルター5
// ロジック売り1フィルター
if (GMT_Kadou_OK_Sell1 && !isbuy)
{  
// ADXフィルター
   for (int ADXx_sell1=1; ADXx_sell1<=ADXx_sell_count1; ADXx_sell1++)
   {
      double ADX1_Sell1 = iADX(NULL, ADX_TF_Sell1, 14, PRICE_CLOSE, MODE_MAIN, ADXx_sell1);
      if (ADX1_Sell1 <= ADX1_Sell_Value1) return(0);
   }
}

   //エントリーフィルター5ココマデ
   return(3);
}
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| エントリーフィルター6                                            |
//+------------------------------------------------------------------+
int Entry_Filter6(bool isbuy)
{
   //エントリーフィルター6
// ロジック売り2フィルター
if (GMT_Kadou_OK_Sell2 && !isbuy)
{
// ゴトウビフィルター
   if (!(Day() == 5 || Day() == 10 || Day() == 15 || Day() == 20
   || (TimeDayOfWeek(TimeCurrent()) == 5 && ( Day() == 3 || Day() == 4 
                                           || Day() == 8 || Day() == 9 
                                           || Day() == 13 || Day() == 14
                                           || Day() == 18 || Day() == 19 
                                           //|| Day() == 23 || Day() == 24 
                                           //|| Day() == 28 || Day() == 29
                                            )
      )
      ))
   {
      return(0);
   }
   
// ADXフィルター
   for (int ADXx_sell2=1; ADXx_sell2<=ADXx_sell_count2; ADXx_sell2++)
   {
      double ADX1_Sell2 = iADX(NULL, ADX_TF_Sell2, 14, PRICE_CLOSE, MODE_MAIN, ADXx_sell2);
      if (ADX1_Sell2 >= ADX1_Sell_Value2) return(0);
   }
   
   for (int ADXx_sell3=1; ADXx_sell3<=ADXx_sell_count3; ADXx_sell3++)
   {
      double ADX1_Sell3 = iADX(NULL, ADX_TF_Sell3, 14, PRICE_CLOSE, MODE_MAIN, ADXx_sell3);
      if (ADX1_Sell3 <= ADX1_Sell_Value3) return(0);
   }

// Demarkerフィルター   
   double Dem1 = iDeMarker(NULL, Dem_TF1, Dem_PERIOD1, 1 );
   if (Dem1 >= Dem_Limit1) return(0);
}

   //エントリーフィルター6ココマデ
   return(3);
}
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| エントリーフィルター7                                            |
//+------------------------------------------------------------------+
int Entry_Filter7(bool isbuy)
{
   //エントリーフィルター7

   //エントリーフィルター7ココマデ
   return(3);
}
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| 決済ルール1                                                      |
//+------------------------------------------------------------------+
int Exit_Rule1(bool isbuy)
{
   // 決済ルール1
   
   if (!isbuy && (PositionClose_Buy1 || PositionClose_Buy2))
   {
      return(2);
   } // 買いを決済
   
   if (isbuy && (PositionClose_Sell1 || PositionClose_Sell2))
   {
      return(1);
   } // 売りを決済
   
   // 決済ルール1ココマデ
   return(3);
}
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| 決済ルール2                                                      |
//+------------------------------------------------------------------+
int Exit_Rule2(bool isbuy)
{
   // 決済ルール2

   // 決済ルール2ココマデ
   return(3);
}
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| 決済ルール3                                                      |
//+------------------------------------------------------------------+
int Exit_Rule3(bool isbuy)
{
   // 決済ルール3

   // 決済ルール3ココマデ
   return(3);
}
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| 決済ルール4                                                      |
//+------------------------------------------------------------------+
int Exit_Rule4(bool isbuy)
{
   // 決済ルール4

   // 決済ルール4ココマデ
   return(3);
}
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| 決済ルール5                                                      |
//+------------------------------------------------------------------+
int Exit_Rule5(bool isbuy)
{
   // 決済ルール5

   // 決済ルール5ココマデ
   return(3);
}
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| チャート自動セット                                               |
//+------------------------------------------------------------------+
// チャートセット初期化
void ChartSet()
{
// 気配値強制表示&自動切替
   int chartWidth = (int)ChartGetInteger(0, CHART_WIDTH_IN_PIXELS); // チャート幅の計算
   int textWidth = 200;//StringLen(WindowExpertName()) * 12; // 固定値pxまたはテキストの幅の計算
   double ShiftPer = textWidth * 100 / chartWidth;
   
   if (!IsTesting())
   {
      if (StringSubstr(Symbol(), 0, 6) != SYMBOL1 || Period() != Chart_TimeFrame) 
      {
         SymbolSelect(SYMBOL1 + StringSubstr(Symbol(), 6, StringLen(Symbol())), true);
         ChartSetSymbolPeriod(0, SYMBOL1 + StringSubstr(Symbol(), 6, StringLen(Symbol())), Chart_TimeFrame);
      }
      // 現在のシンボルが4文字の場合。無しならコメントアウト
      /*if (StringSubstr(Symbol(), 0, 4) != SYMBOL2 || Period() != Chart_TimeFrame)
      {
         SymbolSelect(SYMBOL2 + StringSubstr(Symbol(), StringSubstr(Symbol(), 0, 4) == SYMBOL2? 4 : 6, StringLen(Symbol())), true);
         ChartSetSymbolPeriod(0, SYMBOL2 + StringSubstr(Symbol(), StringSubstr(Symbol(), 0, 4) == SYMBOL2? 4 : 6, StringLen(Symbol())), Chart_TimeFrame);
      }*/
      ChartSetInteger(0, CHART_COLOR_BACKGROUND, clrBlack);
      ChartSetInteger(0, CHART_COLOR_FOREGROUND, clrWhite);
      ChartSetInteger(0, CHART_COLOR_GRID, clrLightSlateGray);
      ChartSetInteger(0, CHART_COLOR_CHART_UP, clrOlive);
      ChartSetInteger(0, CHART_COLOR_CHART_DOWN, clrOlive);
      ChartSetInteger(0, CHART_COLOR_CANDLE_BULL, clrBlack);
      ChartSetInteger(0, CHART_COLOR_CANDLE_BEAR, clrBeige);
      ChartSetInteger(0, CHART_COLOR_CHART_LINE, clrOlive);
      ChartSetInteger(0, CHART_COLOR_VOLUME, clrOlive);
      ChartSetInteger(0, CHART_COLOR_ASK, clrRed);
      ChartSetInteger(0, CHART_COLOR_STOP_LEVEL, clrRed);
      ChartSetInteger(0, CHART_SHIFT, true);
      ChartSetDouble(0, CHART_SHIFT_SIZE, ShiftPer);
      ChartSetInteger(0, CHART_AUTOSCROLL, true);
      //ChartSetInteger(0, CHART_SHOW_DATE_SCALE, true); // これを入れるとなぜか表示範囲が狭くなる
      //ChartSetInteger(0, CHART_SHOW_PRICE_SCALE, true); // これを入れるとなぜか表示範囲が狭くなる
      ChartSetInteger(0, CHART_FOREGROUND, false);
      ChartSetInteger(0, CHART_SHOW_GRID, false);
      ChartSetInteger(0, CHART_SHOW_ONE_CLICK, false);
      ChartSetInteger(0, CHART_SHOW_OHLC, false);
      ChartSetInteger(0, CHART_SHOW_PERIOD_SEP, true);
      ChartSetInteger(0, CHART_SHOW_ASK_LINE, true);
      ChartSetInteger(0, CHART_SCALE, 3);
      ChartSetInteger(0, CHART_MODE, CHART_CANDLES);
   }
}
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| チャートの中央にシンボルを描画する                               |
//+------------------------------------------------------------------+
void CenterSymbol()
{
   string TEXT1 = StringSubstr(Symbol(), 0, 6);
   string TEXT2 = (Period() == 1? "M1": Period() == 5? "M5": Period() == 15? "M15": Period() == 30? "M30":
   Period() == 60? "H1": Period() == 240? "H4": Period() == 1440? "D1": Period() == 10080? "W1": "MN1")
   + "/" + DoubleToStr(MarketInfo(Symbol(),MODE_SPREAD) / 10, 1);
   int FontSize = 36; 
   
   int chartWidth = (int)ChartGetInteger(0, CHART_WIDTH_IN_PIXELS);
   int chartHeight = (int)ChartGetInteger(0, CHART_HEIGHT_IN_PIXELS);
   int textWidth = StringLen(TEXT1) * FontSize / 2; // テキストの幅の計算
   int textHeight = FontSize; // テキストの高さ

   // テキストの中心からの座標を計算
   int x = (chartWidth - textWidth) / 2 + textWidth / 2;
   int y = (chartHeight - textHeight) / 2 + textHeight / 2;
   
   DrawTextInCenter("Symbol1", TEXT1, x, y - FontSize, FontSize, C'60, 60, 60');
   DrawTextInCenter("Symbol2", TEXT2, x, y + FontSize, FontSize, C'60, 60, 60');
}
void DrawTextInCenter(string Symbolname, string label_text, int pos_x, int pos_y, int s, color clr= clrBlack)
{
    ObjectCreate(Symbolname, OBJ_LABEL, 0, 0, 0);
    ObjectSetString(0, Symbolname, OBJPROP_TEXT, label_text);
    ObjectSetInteger(0, Symbolname, OBJPROP_FONTSIZE, s);
    ObjectSetString(0, Symbolname, OBJPROP_FONT, "Segoe UI");
    ObjectSetInteger(0, Symbolname, OBJPROP_XDISTANCE, pos_x);
    ObjectSetInteger(0, Symbolname, OBJPROP_YDISTANCE, pos_y);
    ObjectSetInteger(0, Symbolname, OBJPROP_COLOR, clr);
    ObjectSetInteger(0, Symbolname, OBJPROP_BACK, true);
    ObjectSetInteger(0, Symbolname, OBJPROP_SELECTABLE, false);
    ObjectSetInteger(0, Symbolname, OBJPROP_ANCHOR, ANCHOR_CENTER); 
}
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| EAの状態を表示                                                   |
//+------------------------------------------------------------------+
void OnTimer()
{
   EA_test();
   
   if (CT == 0)
   {
      EA_label ("Updating...", clrYellow);
      ChartWarning = 1; // この変数は、チャート表示やチャートコメント表示と連動
      ChartSet2();
      CT = 0;
   }
}
void EA_test()
{
   string label1 = "EA is running";
   string label2 = "Authentication Failed";
   string label3 = "No trade allowed";
   string label4 = "Network Errors";
  
   string labelx = label1;
   if (Pass == false) labelx = label2;
   else if (IsTradeAllowed() == false) labelx = label3;
   else if (IsConnected() == false) labelx = label4;
  
   
   if (Pass == false)
   {
      EA_label (label2, clrOrangeRed);
      ChartWarning = 2;
      ChartSet2();
   }
   else if (IsTradeAllowed() == false)
   {
      EA_label (label3, clrOrangeRed);
      ChartWarning = 3;
      ChartSet2();
   }
   else if (IsConnected() == false)
   {
      EA_label (label4, clrOrangeRed); 
      ChartWarning = 4;
      ChartSet2();
   }
   else
   {
      EA_label (label1, clrLime);
      ChartWarning = 0;
      ChartSet2();
   }
   
}
void EA_label(string text, color clr)
{
   int x = (int)NormalizeDouble(4 * DPIAdjust, 0); // 別途DPI換算コードで調整
   int y = (int)NormalizeDouble(18 * DPIAdjust, 0); // 別途DPI換算コードで調整
   
   ObjectCreate(0, "EA_label", OBJ_LABEL, 0, 0, 0);
   ObjectSetString(0, "EA_label", OBJPROP_TEXT, text);
   ObjectSetInteger(0, "EA_label", OBJPROP_COLOR, clr);
   ObjectSetInteger(0, "EA_label", OBJPROP_XDISTANCE, x);
   ObjectSetInteger(0, "EA_label", OBJPROP_YDISTANCE, y);
   ObjectSetInteger(0, "EA_label", OBJPROP_FONTSIZE, 10);
   ObjectSetInteger(0, "EA_label", OBJPROP_SELECTABLE, false);
   ObjectSetInteger(0, "EA_label", OBJPROP_HIDDEN, true);
   ObjectSetString(0, "EA_label", OBJPROP_FONT, "Segoe UI");
   ObjectSetInteger(0, "EA_label", OBJPROP_CORNER, CORNER_RIGHT_UPPER);
   ObjectSetInteger(0, "EA_label", OBJPROP_ANCHOR, ANCHOR_RIGHT_UPPER); 
   ObjectSetInteger(0, "EA_label", OBJPROP_BACK, false);
}
// 状態によるチャート配色変更
void ChartSet2()
{
   color ChartWar1 = ChartWarning >= 2? clrDarkGray : clrWhite;
   color ChartWar2 = ChartWarning >= 2? clrDimGray : clrOlive;
   color ChartWar3 = ChartWarning >= 2? clrSilver : clrBeige;

   if (!IsTesting())
   {
      ChartSetInteger(0, CHART_COLOR_BACKGROUND, clrBlack);
      ChartSetInteger(0, CHART_COLOR_FOREGROUND, ChartWar1);
      ChartSetInteger(0, CHART_COLOR_GRID, clrLightSlateGray);
      ChartSetInteger(0, CHART_COLOR_CHART_UP, ChartWar2);
      ChartSetInteger(0, CHART_COLOR_CHART_DOWN, ChartWar2);
      ChartSetInteger(0, CHART_COLOR_CANDLE_BULL, clrBlack);
      ChartSetInteger(0, CHART_COLOR_CANDLE_BEAR, ChartWar3);
      ChartSetInteger(0, CHART_COLOR_CHART_LINE, ChartWar2);
      ChartSetInteger(0, CHART_COLOR_VOLUME, ChartWar2);
      ChartSetInteger(0, CHART_COLOR_ASK, clrRed);
      ChartSetInteger(0, CHART_COLOR_STOP_LEVEL, clrRed);

   }
}
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| チャートコメント表示                                             |
//+------------------------------------------------------------------+
void ChartComment()
{
   color clrChartWar = ChartWarning >= 2? clrNONE : clrWhite;
   color clrChartWarPP = ChartWarning >= 2? clrNONE : totalpips < 0? clrOrangeRed : clrWhite;
   color clrChartWarPF = ChartWarning >= 2? clrNONE : 0 < ProfitFactor && ProfitFactor < 1? clrOrangeRed : clrWhite;
   color clrChartWarCom = (_Comment == "" || StringLen(_Comment) > 31) ? clrOrangeRed : clrChartWar;
   
   string LotsComment;
   if (MM_ON == Fixed) LotsComment = DoubleToStr(Lots,2);
   else LotsComment = DoubleToStr(CalculateLots(MM_Risk, MaxStopLoss_pips),2) +
                      " (" + DoubleToStr(MM_Risk,1) +"%)";

   string Comment0  = "Magic : " + (string)MagicNumber;
   string Comment1  = "Lots : " + LotsComment;
   string Comment2  = "MM : " + (MM_ON == 0 ? "Fixed" : MM_ON == 1 ? "FreeMargin" : MM_ON == 2 ? "Balance" : "AddCredit");
   string Comment3  = "Summertime : " + (Summertime == 0 ? "none" : Summertime == 1 ? "US" : "UK");
   //string Comment4  = "Slippage log : " + (string)Measurement;
   string Comment5  = "Spread Lim/Ave : " + DoubleToStr(MaxSpread_pips,1) + "/" + DoubleToStr(SpreadAve,1);
   string Comment6  = "TradeCounts : " + DoubleToStr(TradeCounts, 0);
   string Comment7  = "Profit (pips) : " + DoubleToStr(totalpips, 1);
   string Comment8  = (plus_profit == 0 || minus_profit == 0? "Profit factor : ---" :
                      "Profit factor : " + DoubleToStr(ProfitFactor, 2));
   string Comment9  = (plus_profit == 0 || minus_profit == 0? "RRR/Win% : ---/---" :
                      "RRR/Win% : " + DoubleToStr(RRR, 2) + "/" + DoubleToStr(WinPer, 1));
   string Comment10 = "[OrderComment]";
   string Comment11 = _Comment;
   string Comment12 = "------------------------------";
   string Comment13 = "Logic_Buy1: " + (string)Logic_Buy1;
   string Comment14 = "TP/SL: " + DoubleToStr(TakeProfit_pips_Buy1,0) + "/" + DoubleToStr(StopLoss_pips_Buy1,0);
   string Comment15 = "Modify: " + (string)Modify_Buy1;
   string Comment16 = "Logic_Buy2: " + (string)Logic_Buy2;
   string Comment17 = "TP/SL: " + DoubleToStr(TakeProfit_pips_Buy1,0) + "/" + DoubleToStr(StopLoss_pips_Buy1,0);
   string Comment18 = "Logic_Sell1: " + (string)Logic_Sell1; 
   string Comment19 = "TP/SL: " + DoubleToStr(TakeProfit_pips_Sell1,0) + "/" + DoubleToStr(StopLoss_pips_Sell1,0);
   string Comment20 = "Logic_Sell2: " + (string)Logic_Sell2; 
   string Comment21 = "TP/SL: " + DoubleToStr(TakeProfit_pips_Sell2,0) + "/" + DoubleToStr(StopLoss_pips_Sell2,0);
   string Comment22 = "------------------------------";
   
  
   CommentLabel("ComObj0",  Comment0,  4,  38, 10, clrYellow);
   CommentLabel("ComObj1",  Comment1,  4,  58, 10, clrYellow);
   CommentLabel("ComObj2",  Comment2,  6,  82,  8, clrChartWar);
   CommentLabel("ComObj3",  Comment3,  6, 100,  8, clrChartWar);
   //CommentLabel("ComObj4",  Comment4,  6, 118,  8, clrChartWar);
   CommentLabel("ComObj5",  Comment5,  6, 118,  8, clrChartWar);
   CommentLabel("ComObj6",  Comment6,  6, 136,  8, clrChartWar);
   CommentLabel("ComObj7",  Comment7,  6, 154,  8, clrChartWarPP);
   CommentLabel("ComObj8",  Comment8,  6, 172,  8, clrChartWarPF);
   CommentLabel("ComObj9",  Comment9,  6, 190,  8, clrChartWar);
   CommentLabel("ComObj10", Comment10, 6, 208,  8, clrChartWarCom);
   CommentLabel("ComObj11", Comment11, 6, 230,  6, clrChartWar);
   CommentLabel("ComObj12", Comment12, 6, 238,  8, clrChartWar);
   CommentLabel("ComObj13", Comment13, 6, 252,  8, clrChartWar);
   CommentLabel("ComObj14", Comment14, 6, 270,  8, clrChartWar);
   CommentLabel("ComObj15", Comment15, 6, 288,  8, clrChartWar);
   CommentLabel("ComObj16", Comment16, 6, 306,  8, clrChartWar);
   CommentLabel("ComObj17", Comment17, 6, 324,  8, clrChartWar);
   CommentLabel("ComObj18", Comment18, 6, 342,  8, clrChartWar);
   CommentLabel("ComObj19", Comment19, 6, 360,  8, clrChartWar);
   CommentLabel("ComObj20", Comment20, 6, 378,  8, clrChartWar);
   CommentLabel("ComObj21", Comment21, 6, 396,  8, clrChartWar);
   CommentLabel("ComObj22", Comment22, 6, 410,  8, clrChartWar);

}
// チャートコメントの仕様
void CommentLabel(string ComName, string ComText, int ComPos_x, int ComPos_y, int ComSize, color ComClr= clrBlack)
{
   ComPos_x = (int)NormalizeDouble(ComPos_x * DPIAdjust, 0); // 別途DPI換算コードで調整
   ComPos_y = (int)NormalizeDouble(ComPos_y * DPIAdjust, 0); // 別途DPI換算コードで調整
   
   ObjectCreate(ComName, OBJ_LABEL, 0, 0, 0);
   ObjectSetString (0, ComName, OBJPROP_TEXT, ComText);
   ObjectSetInteger(0, ComName, OBJPROP_XDISTANCE, ComPos_x);
   ObjectSetInteger(0, ComName, OBJPROP_YDISTANCE, ComPos_y);
   ObjectSetInteger(0, ComName, OBJPROP_FONTSIZE, ComSize);
   ObjectSetInteger(0, ComName, OBJPROP_COLOR, ComClr);
   ObjectSetString (0, ComName, OBJPROP_FONT, "Segoe UI");
   ObjectSetInteger(0, ComName, OBJPROP_BACK, true);
   ObjectSetInteger(0, ComName, OBJPROP_SELECTABLE, false);
   ObjectSetInteger(0, ComName, OBJPROP_CORNER, CORNER_RIGHT_UPPER);
   ObjectSetInteger(0, ComName, OBJPROP_ANCHOR, ANCHOR_RIGHT_UPPER);
}
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| チャートにトレード履歴表示                                       |
//+------------------------------------------------------------------+
void PosHis()
{
   int res;
   double pips = 0;
   
   for (int i = OrdersTotal() - 1; i >= 0; i--)
   {
      res = OrderSelect(i, SELECT_BY_POS);
      if (OrderSymbol() != Symbol() || OrderType() > 1 || OrderMagicNumber() != MagicNumber)
      continue;
      pips += trend((string)OrderTicket(), OrderOpenTime(), OrderOpenPrice(), Time[0], OrderType() == 0 ? Bid : Ask, OrderType());
   }
}
//+------------------------------------------------------------------+
void history()
{
   int res;
   totalpips = 0;
   plus_profit = 0;
   minus_profit = 0;//, ProfitFactor = 0;
   minus_count = 0;
   plus_count = 0;
   TradeCounts = 0;
   
// トレード履歴を検索
   for (int i = OrdersHistoryTotal() - 1; i >= 0; i--)
   {
      res = OrderSelect(i, SELECT_BY_POS, MODE_HISTORY);
      if (OrderSymbol() != Symbol() || OrderType() > 1 || OrderMagicNumber() != MagicNumber)
      continue;
      
      // 合計pips計算
      totalpips += trend((string)OrderTicket(), OrderOpenTime(), OrderOpenPrice(), OrderCloseTime(), OrderClosePrice(), OrderType());
      
      // プロフィットファクター・RRR・勝率計算
      if (OrderProfit() < 0)
      {
         minus_profit -= OrderProfit();
         minus_count += 1;
      }
      else if (OrderProfit() >= 0)
      {
         plus_profit += OrderProfit();
         plus_count += 1;
      }
      if (minus_profit != 0 && plus_count != 0 && minus_count != 0) 
      {
         ProfitFactor = plus_profit / minus_profit;
         RRR = (plus_profit / plus_count) / (minus_profit / minus_count);
         WinPer = (plus_count * 100) / (plus_count + minus_count);
      }
      TradeCounts = minus_count + plus_count;
   }
}
//+------------------------------------------------------------------+
double trend(string obj_name, datetime Time1, double Close1, datetime Time2, double Close2, int type)
{
   double pips = (double)DoubleToStr((type == 0 ? Close2 - Close1 : Close1 - Close2) / Point() * 0.1 - tes, 1);
   int Shift2 = iBarShift(NULL, 0, Time2);
   datetime Timex = iTime(NULL, 0, Shift2 + 1);
   
// トレード線
   ObjectDelete("hislt" + obj_name);
   ObjectCreate(0, "hislt" + obj_name, OBJ_TREND, 0, Time1, Close1, Time2, Close2);
   ObjectSetInteger(0, "hislt" + obj_name, OBJPROP_COLOR, type == 0 ? clrDodgerBlue : clrOrangeRed);
   ObjectSetInteger(0, "hislt" + obj_name, OBJPROP_STYLE, 0);
   ObjectSetInteger(0, "hislt" + obj_name, OBJPROP_WIDTH, 2);
   ObjectSetInteger(0, "hislt" + obj_name, OBJPROP_SELECTABLE, false); // オブジェクトの選択可否設定
   ObjectSetInteger(0, "hislt" + obj_name, OBJPROP_RAY_RIGHT, false); // 右に線を延長
 
// トレード線内のpips表示
   // 文字本体
   ObjectDelete("hislx" + obj_name);
   ObjectCreate(0, "hislx" + obj_name, OBJ_TEXT, 0, Timex, Close2);
   ObjectSetInteger(0, "hislx" + obj_name, OBJPROP_COLOR, pips < 0 ? clrOrangeRed : !IsTesting()? clrLime : clrYellow);//type == 0 ? BuyColor : SellColor);
   ObjectSetInteger(0, "hislx" + obj_name, OBJPROP_SELECTABLE, false); // オブジェクトの選択可否設定
   ObjectSetInteger(0, "hislx" + obj_name, OBJPROP_FONTSIZE, 12);    // フォントサイズ
   ObjectSetInteger(0, "hislx" + obj_name, OBJPROP_ANCHOR, ANCHOR_RIGHT); // 描画位置
   ObjectSetString(0, "hislx" + obj_name, OBJPROP_TEXT, DoubleToStr(pips, 1)); // 表示するテキスト
   ObjectSetString(0, "hislx" + obj_name, OBJPROP_FONT, "Segoe UI Semibold"); // フォント

   return(pips);
}
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| スプレッド計測・オートスプレッド                                 |
//+------------------------------------------------------------------+
// 各スプレッド値計算
void MeasureSP()
{
   TickCount++;
   SpreadSum += MeasureSpread;
   SpreadMin = SpreadMin == 0 ? SpreadMin = MeasureSpread : SpreadMin;
   if (TickCount > 0 && SpreadSum > 0) SpreadAve = SpreadSum / TickCount;
   if (SpreadMax < MeasureSpread) SpreadMax = MeasureSpread;
   if (SpreadMin > MeasureSpread) SpreadMin = MeasureSpread;
   
   // MT4時間1:00のスプレッド
   yTime = TimeMinute(TimeCurrent());
   if (xxTime == 1 && yTime == 0)
   {
      TickCount1++;
      SpreadSum1 += MeasureSpread;
      SpreadMin1 = SpreadMin1 == 0 ? SpreadMin1 = MeasureSpread : SpreadMin1;
      if (TickCount1 > 0 && SpreadSum1 > 0) SpreadAve1 = SpreadSum1 / TickCount1;
      if (SpreadMax1 < MeasureSpread) SpreadMax1 = MeasureSpread;
      if (SpreadMin1 > MeasureSpread) SpreadMin1 = MeasureSpread;
   }
   
   // 月足のバー更新時に累積値リセット
   if (lastBars != iBars(NULL, PERIOD_MN1))
   {
      lastBars = iBars(NULL, PERIOD_MN1);
      SpreadSum = 0;
      TickCount = 0;
      SpreadSum1 = 0;
      TickCount1 = 0;
   }
   
   // オートスプレッド設定機能
   Adjustspread = SpreadAve + Adjustspread_Margin; // 平均にマージン加算
   MaxSpread_pips = MathMin(Adjustspread, AllowMaxSpread); // 内部設定の最大値とマージン加算を比較し小さい方を採用

   if (SpreadAve1 != 0) // 1:00エントリーEA用
   {
      Adjustspread = SpreadAve1 + Adjustspread_Margin1; // 平均にマージン加算
      MaxSpread_pips = MathMax(MathMin(Adjustspread, AllowMaxSpread), MaxSpread_pips); // 最大値とマージン加算、全体平均を比較
   }
   
}
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| 実行スプレッド・スリッページ・実行スプレッド計測・ファイル作成   |
//+------------------------------------------------------------------+
// ファイル初期化
/*int FileInit()
{
   filename = AccountCompany() + "_スリッページログ.csv";// ファイル名を決める
      
   fp = FileOpen(filename, FILE_READ|FILE_WRITE|FILE_CSV, ',');// ファイルオープン(csv)
   if(fp==INVALID_HANDLE)
   {
      err = GetLastError();
      printf("Error occured: [%d] %s", err, ErrorDescription(err));
      return(0.0);
   }
   FileWrite(fp, "注文番号", "注文時間", "時刻", "分", "取引種別", "注文価格", "約定価格", 
             "スプレッド(pips)", "スリッページ(pips)", "レイテンシー(ms)", 
             "損益(pips)", "数量", "通貨ペア", "時間足",  "EA名");
   // ファイルを閉じる
   FileClose(fp);
  
  return(0);
}

// トレード情報
void OpenTradeInfo()
{
   OpenLatency = GetTickCount() - StartOrderTimestamp; // レイテンシー計測
   Order_Price = NormalizeDouble(Order_Price , Digits); // 買い注文価格を正規化
   Open_Yakujyou_Price = NormalizeDouble(OrderOpenPrice(), Digits); // 実際約定した価格、正規化
   Open_Slippage = NormalizeDouble(OrderType() == OP_BUY? Order_Price - Open_Yakujyou_Price : 
                   Open_Yakujyou_Price - Order_Price, Digits) / xpoint; // スリッページ、桁合わせ
   Open_Spread = NormalizeDouble(OSpread, Digits) / xpoint; // スプレッド、桁合わせ
   Open_Type = OrderType() == OP_BUY? "Buy" : "Sell";
   FileWriteingOpen(); // 書き込み処理
}
void CloseTradeInfo()
{
   Close_Price = NormalizeDouble(Close_Price, Digits); // 売り注文価格を正規化
   Close_Yakujou_Price = NormalizeDouble(OrderClosePrice(), Digits); // 実際約定した価格
   Close_Slippage = NormalizeDouble(OrderType() == OP_BUY? Close_Yakujou_Price - Close_Price : 
                    Close_Price - Close_Yakujou_Price, Digits) / xpoint; // スリッページ、桁合わせ
   Close_Spread = NormalizeDouble(CSpread, Digits) / xpoint; // スプレッド、桁合わせ
   profitpips = NormalizeDouble(OrderType() == OP_BUY? (OrderClosePrice() - OrderOpenPrice()) / xpoint :
                (OrderOpenPrice() - OrderClosePrice()) / xpoint, 1);
   Close_Type = "Close";
   FileWriteingClose(); // 書き込み処理
}

// ファイル書き込み
void FileWriteingOpen()
{
   for(int i = 0; i < 3000; i++)
   {
      fp = FileOpen(filename, FILE_READ|FILE_WRITE|FILE_CSV, ',');// ファイルオープン(csv)、失敗戻り値は-1
      
      if (fp != INVALID_HANDLE)
      {
         FileSeek(fp, 0, SEEK_END);
         FileWrite(fp, OrderTicket(), OrderOpenTime(), Hour(), Minute(), Open_Type, Order_Price, Open_Yakujyou_Price,
                   Open_Spread, Open_Slippage, OpenLatency, 
                   "---", CalculateLots(MM_Risk, MaxStopLoss_pips), Symbol(), Timeframe, WindowExpertName());
         FileClose(fp);
         break;
      }
   }  
   if (fp == -1) Print("Error=", GetLastError(), "  ファイルの書き込みに失敗しました");
}
void FileWriteingClose()
{
   for(int i = 0; i < 3000; i++)
   {
      fp = FileOpen(filename, FILE_READ|FILE_WRITE|FILE_CSV, ',');// ファイルオープン(csv)、失敗戻り値は-1
      
      if (fp != INVALID_HANDLE)
      {
         FileSeek(fp, 0, SEEK_END);
         FileWrite(fp, OrderTicket(), OrderCloseTime(), Hour(), Minute(), Close_Type, Close_Price, Close_Yakujou_Price,
                   Close_Spread, Close_Slippage, CloseLatency, 
                   profitpips, CalculateLots(MM_Risk, MaxStopLoss_pips), Symbol(), Timeframe, WindowExpertName());
         FileClose(fp);
         break;
      }
   }
   if (fp == -1) Print("Error=", GetLastError(), "  ファイルの書き込みに失敗しました");
}

// TP/SL時の検出
void ClosedTradeTPSL()
{
   for(int i=OrdersHistoryTotal()-1; i>=0; i--)
   {
      //オーダー選択(エラーを生じた場合、ループから抜け出す)
      if (OrderSelect( i, SELECT_BY_POS, MODE_HISTORY ) == false)
      {
         Print("OrderSelect returned the error of ", GetLastError() );
         break;
      }
      //オーダー確認（通貨ペアが一致しない場合は、for文の先頭に戻る）
      if (OrderSymbol() != Symbol()) continue;
      
      //マジックナンバー確認（マジックナンバーが一致しない場合は、for文の先頭に戻る）
      if (OrderMagicNumber() != MagicNumber) continue;
      
      // 決済時間に更新がなければループ処理終了
      if((OrderType() == OP_BUY || OrderType() == OP_SELL) && OrderCloseTime() == OrderCloseTime_bak) break;
      
      if((OrderType() == OP_BUY || OrderType() == OP_SELL) && OrderCloseTime() > OrderCloseTime_bak) // 決済時間が最新であれば
      {
         OrderCloseTime_bak = OrderCloseTime();
         int length = StringLen(OrderComment());//StringLenは文字数を返す
         if (length >= 4)
         {
         // TP/SL決済の確認
            string tpsl = StringSubstr(OrderComment(), length-4, 4);
            if (tpsl == "[tp]" || tpsl == "[sl]")
            {
               Close_Price = NormalizeDouble((tpsl == "[tp]"? OrderTakeProfit() : OrderStopLoss()), Digits); // 売り注文価格を正規化
               Close_Yakujou_Price = NormalizeDouble(OrderClosePrice(), Digits); // 実際約定した価格
               Close_Slippage = NormalizeDouble(OrderType() == OP_BUY? Close_Yakujou_Price - Close_Price : Close_Price - Close_Yakujou_Price, Digits) / xpoint; // スリッページ、桁合わせ
               Close_Spread = MarketInfo(NULL,MODE_SPREAD) / 10; // スプレッド、桁合わせ
               profitpips = NormalizeDouble((OrderType() == OP_BUY? OrderClosePrice() - OrderOpenPrice() : OrderOpenPrice() - OrderClosePrice()) / xpoint, 1);
               Close_Type = tpsl == "[tp]"? "TP" : "SL";
               FileWriteingClose(); // 書き込み処理
               
               break;
            }            
         }
      }
   }
}*/
//+------------------------------------------------------------------+