//+------------------------------------------------------------------+
//|                                            Present02_USDJPY_M30  |
//|こちらをクリックすると、EAに関する有益な情報や自作EAの紹介をご覧いただけます |
//|                                       https://note.com/efukikaku |
//+------------------------------------------------------------------+
#property copyright "こちらをクリックすると、EAに関する有益な情報や自作EAの紹介をご覧いただけます。"
#property link      "https://note.com/efukikaku"
#property version   "1.0"


//#property       Present02_USDJPY_M30_1.0 → Present02_USDJPY_M30_Share 1.0


#property description "通貨ペア：USDJPY"
#property description "時間足：M15・M30"
#property description "スタイル：スイング"
//#property description "ポジション数：2"
//#property description "両建て：有り  トレール：有り"
//#property description "TP：変動  SL：買／売pips（変更不可）"
#property description "週末持ち越し：有り"
#property description "12/20~1/3：新規エントリー無し・決済のみ実行"
#property description "日足5本以外：不可"
//#property description "配布版制限：サマータイム米国式限定・ロット0.08以下のみ稼働"

#property strict
#include <stdlib.mqh>
/*
//許可する口座No.
int validAccount1 = 8315351; 
int validAccount2 = 12345678;
int validAccount3 = 98765432;
*/
/*
//期間縛り
int EntryStop_year = 2024;
int EntryStop_month = 9;
int EntryStop_day = 1;
*/
//+------------------------------------------------------------------+
//|ユーザー入力用パラメーター                                        |
//+------------------------------------------------------------------+
input int        MagicNumber         =  51729042;    // マジックナンバー（他EAと重複不可）
enum  MM_Select{
      Fixed, // 0：単利/固定
      FreeMargin, // 1：複利/余剰証拠金
      Balance, // 2：複利/残高
      AddCredit,  // 3：複利/残高+クレジット
      };
input MM_Select  MM_ON               = Fixed;       // 複利機能（0:固定/1:余剰証拠金/2:残高）
input double     Lots                = 0.1;         // ロット（単利運用時）
input double     MM_Risk             = 1.0;         // リスク％（余剰証拠金/残高の何%か）
 double     MaxSpread_pips           = 10.0;        // 許容スプレッド（Pips）
input double     AllowSpread         = 10;          // 許容スプレッドPips（0:自動）
input int        GMT                 = 2;           // GMT（冬時間）
enum  Summertime_Select{
      None, // 0：none/無し
      US,   // 1：US/米国式
      UK,   // 2：UK/英国式
      };
input Summertime_Select  Summertime  =       US;    // サマータイム（0:無し/1:米/2:英）

//+------------------------------------------------------------------+
//|内部設定・グローバル関数                                          |
//+------------------------------------------------------------------+
//内部設定
int      Maxposition                 = 1;           // 最大ポジション
//int CountBuy = 0,CountSell = 0;
 double  Gap_Pips                    = 3.0;         // 【共通】ギャップpips（1:00以外）
 double  Gap_Pips_1                  = 10.0;        // 【共通】ギャップpips（1:00）
int      CandleCheckCount            = 1000;          // 【共通】過去ボラティリティチェックHLローソク足本数 *****
//int      CandleCloseHour           = 9;           // 強制決済するポジション保有時間
int      Slippage                    = 100;         // 許容スリッページ（Point）
int      TakeProfit_pips             = 1000;        // 利確指値（Pips）
int      StopLoss_pips               = 1500;         // 【共通】最大SL（Pips）
bool     WeekendClose                = false;       // 週末クローズ
bool     YearendClose                = true;        // 12/20~1/3クローズ
string   _Comment                    = "Present02_USDJPY_M30_1.0";   // 通知用コメント

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

//バーカウント・桁合わせ・時間制御用
double   xpoint;
int      xTime, xxTime, xxxTime, yTime;
int      AdjustedDay, AdjustedWeek, AdjustedMonth;

//週末決済（日本時間）
bool     GMT_Kadou_NG                = false;       // 週末稼働
bool     PositionClose               = false;       // 週末決済
int      EntryNG_StartTime1          = 1;           // エントリー中止時間（開始） / 0~4(<Time_W) / 1
int      EntryNG_EndTime1            = 7;           // エントリー中止時間（終了）
int      EntryNG_DayOfWeek1          = 6;           // エントリー中止曜日
int      PositionClose_Time_W        = 5;           // ポジション決済時間 / 0~5 / 1
int      PositionClose_DayOfWeek1    = 6;           // ポジション決済曜日

//ロジック毎の時間割り振り（サーバー時間）
bool     Logic1_Time                 = true;        // ロジック1時間帯
int      EntryOK_StartTime1          = 1;           // ロジック1開始時間1
int      EntryOK_EndTime1            = 23;          // ロジック1終了時間1
int      EntryOK_StartTime2          = 1;           // ロジック1開始時間2
int      EntryOK_EndTime2            = 23;          // ロジック1終了時間2

bool     Logic1_NG_Time               = true;        // ロジック1時間帯
int      Entry_NG_StartTime1          = 0;           // ロジック1 NG開始時間1
int      Entry_NG_EndTime1            = 1;          // ロジック1 NG終了時間1

//バックテスト用モード切替
 bool     ROMode                     = false;       // RO時間トレードなし
bool     ROTime                      = false;       // ロールオーバー・メンテナンス時間
 bool     Development                = false;       // 開発モードON/OFF（OnTester欄にRF表示、インジケータ表示）
 bool     Modify                     = true;
 bool     Buy_Entry                  = true;        // 買いエントリー
 bool     Sell_Entry                 = true;        // 売りエントリー


//+------------------------------------------------------------------+
//|ロジック用パラメータ                                              |
//+------------------------------------------------------------------+


//+------------------------------------------------------------------+
//|買い                                                              |
//+------------------------------------------------------------------+
//エントリー・決済ベースルールの各変数
int      MA_Perfect_Order_period1 = 20;  // 短期移動平均線      // 30 10(10)200
int      MA_Perfect_Order_period2 = 50;  // 中期移動平均線
//input int      MA_Perfect_Order_period3 = 100; // 長期移動平均線
ENUM_TIMEFRAMES MA_Perfect_Order_TIMEFRAMES = PERIOD_M30;     //MA_Perfect_Orderタイムフレーム

//エントリーフィルター

 
int      ATR_Period = 10; // ATRの計算期間       // フィルターのみ M15 0.005(0.005)1.1  M30_0.05(0.02)1  H1_0.1(0.02)1  H4_0.2(0.05)1.5   D1_1(0.1)4.5
double   ATR_Filter_Line = 0.5781; // ATRがこの数値以下の時のみエントリー出来る  // 決済込み M15 0.05(0.02)1.1
double   ATR_Exit_Filter_Line = 0.5781; // ATR_Exitがこの数値以上の時決済
ENUM_TIMEFRAMES ATR_TIMEFRAMES = PERIOD_M30;     //ATRタイムフレーム
int      ATR_Exit_Period = 1; // ATR_Exitの計算期間

double   ATR_x = 1.5; // ATRの平均値をｘ倍掛ける
int   ATR_n = 5; // ATRのn本前から調べるか
int      ATR_x_Period_1 = 1; // ATRの1期間 計算期間

int      PercentK_period = 40; // ストキャスティックス%Kの計算期間      // 25(5)70
int      PercentD_period = 60; // ストキャスティックス%Dの計算期間
int      Slow_period = 60; // ストキャスティックスslowDの計算期間
int      Stochastics_LINE = 30; // ストキャスティックスの順張り基準ライン
int      Stochastics_Exit_LINE = 30; // ストキャスティックスの順張り基準ライン
ENUM_TIMEFRAMES Stochastic_TIMEFRAMES = PERIOD_H4;     //Stochasticタイムフレーム

int      ADX_Period = 180; // ADXの計算期間        // 5(5)40  5(5)50
int      ADX_Filter_Line = 5; // ADXがこの数値以上の時のみエントリー出来る
ENUM_TIMEFRAMES ADX_TIMEFRAMES = PERIOD_H4;     //ADX_タイムフレーム
int      ADX_Exit_Line = 20; // ADX決済する数値
//input int      ADX_nhon = 10;  //ADX最大値を何本遡って調べるか
//input int      ADX_Percent = 50;  //ADX最大値から何％下がったら決済するか

int      MA_Kairi_period1 = 1; // 乖離短期移動平均線        // 0.2(0.2)10  0.2(0.2)10
int      MA_Kairi_period2 = 90; // 乖離長期移動平均線
double   MA_Kairi_Filter_percent = 1.8;  // 乖離フィルター移動平均線同士の乖離パーセント
double   MA_Kairi_Exit_percent = 3.4;  // 乖離決済移動平均線同士の乖離パーセント
ENUM_TIMEFRAMES MA_Kairi_TIMEFRAMES = PERIOD_H1;     // 乖離MA_Kairiタイムフレーム

//int MA_Period_Entry_2 = 500; // Candle_Filter長期移動平均線
//ENUM_TIMEFRAMES MA_Filter_TIMEFRAMES = PERIOD_M15;     //MA_Candle_Filterタイムフレーム


//決済ルールの各変数
int         Ichimoku_kumononaka_tenkan = 200;       // 雲の中に入る転換線の計算期間
int         Ichimoku_kumononaka_kijun  = 30;      // 雲の中に入る基準線の計算期間
int         Ichimoku_kumononaka_senkou = 10;      // 雲の中に入る先行スパンの計算期間
ENUM_TIMEFRAMES Ichimoku_kumononaka_TIMEFRAMES = PERIOD_H4;     //Ichimoku_kumononakaタイムフレーム
bool  Kumononaka_Exit = true;  //true　エントリーできる ・　false　エントリーできない

int     Close_CandleCheckCount = 400; // 損切何本前までのローソク足をチェックするか？
ENUM_TIMEFRAMES CandleCheck_TIMEFRAMES = PERIOD_M15;     //CandleCheck_TIMEFRAMESタイムフレーム


double   HL_margin_Ex_mul_buy       =         2.0; // 【買い｜決済】変動TP/HLM倍数  0.5(0.5)10
int      StopLoss_pips_buy          =         120; // 【買い｜決済】損切逆指値（Pips）  10(10)200

//トレーリング
int      HLM_Per_TrailStart_buy     =          1000; // 【買い｜トレール】開始：HLM%  5(5)100
//input int      HLM_Per_ModifyStep_buy     =           2; // 【買い｜トレール】ステップ：HLM%
//input ENUM_TIMEFRAMES BB_TF_Trail   =  PERIOD_M15;
//input int           BB_Period_Trail =          80;
//input double           BB_Hensa_Trail1 =         1.0;
//input double           BB_Hensa_Trail2 =         2.0;
int      OOPMarginPips_buy          =           1000; // 【買い｜トレール】建値+◯pips  2(2)50
int      BarCountSL_Trail_buy       =          1000; // 【買い｜トレール】安値を探すローソク足本数  2(2)50

//+------------------------------------------------------------------+
//|売り                                                              |
//+------------------------------------------------------------------+
//エントリー・決済ベースルールの各変数
 int      MA_Cross_period1_sell      =          80; // 【売り｜エントリー】短期MA期間
 int      MA_Cross_period2_sell      =         100; // 【売り｜エントリー】長期MA期間
 int    HeikenAshi_CheckCount_sell = 4;

//エントリーフィルター


//決済ルールの各変数
int         Ichimoku_kumononaka_Sell_tenkan = 140;       // 雲の中に入る転換線の計算期間
int         Ichimoku_kumononaka_Sell_kijun  = 390;      // 雲の中に入る基準線の計算期間
int         Ichimoku_kumononaka_Sell_senkou = 550;      // 雲の中に入る先行スパンの計算期間
ENUM_TIMEFRAMES Ichimoku_kumononaka_Sell_TIMEFRAMES = PERIOD_H4;     //Ichimoku_kumononakaタイムフレーム
bool  Kumononaka_Sell_Exit = true;  //true　エントリーできる ・　false　エントリーできない

 double   HL_margin_Ex_mul_sell      =         5.0; // 【売り｜決済】変動TP/HLM倍数
 int      StopLoss_pips_sell         =         120; // 【売り｜決済】損切逆指値（Pips）

//トレーリング
 int      HLM_Per_TrailStart_sell    =          50; // 【売り｜トレール】開始：HLM%
//input int      HLM_Per_ModifyStep_sell    =           3; // 【売り｜トレール】ステップ：HLM%
 int      OOPMarginPips_sell         =           3; // 【売り｜トレール】建値+◯pips
 int      BarCountSL_Trail_sell      =           14; // 【売り｜トレール】安値を探すローソク足本数
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| tester function                                                  |
//+------------------------------------------------------------------+
/*double OnTester()
{
    // 開発モードON時、OnTesterに表示【リカバリーファクター｜勝率】
    if (Development == true)
    {
       // リカバリーファクター
       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;
      }
   }
/*
// 口座番号縛り
   if (IsTesting() == false) // バックテスト以外は、許可された口座のみ稼働
   {
      if (!(AccountNumber() == validAccount1 || AccountNumber() == validAccount2 || AccountNumber() == validAccount3))
      {
         Alert("Not allowed account!" +"\n"+ "許可されていない口座です。");
         return(INIT_FAILED); // 初期化が失敗した事を返し、EAを終了させる
      }
   }
*/   
// ロット縛り
   /*if (!IsTesting())
   {
      if (Lots > 0.08) return(INIT_FAILED);
   }
   */

// 最大SL算出（複利の計算で使用）
   StopLoss_pips = MathMax(StopLoss_pips_buy, StopLoss_pips_sell);

// オートスプレッド   
   if (StringSubstr(Symbol(), 0, 6) == "GBPJPY")
   {
      if      (StringSubstr(AccountCompany(), 0, 9) == "Ava Trade" // Ava Trade
            && AllowSpread == 0) MaxSpread_pips = 3.5; //20:55~23:00不可
      
      else if (StringSubstr(AccountCompany(), 0, 15) == "Goldenway Japan" // Goldenway Japan (FXTF)
            && AllowSpread == 0) MaxSpread_pips = 3.0; //23:50~0:53不可
      
      else if (StringSubstr(AccountCompany(), 0, 14) == "Forex Exchange" // Forex Exchange
            && AllowSpread == 0) MaxSpread_pips = 4.0; //23:50~1:09不可
      
      else if (StringSubstr(AccountCompany(), 0, 14) == "Gaitame Finest" // Gaitame Finest
            && AllowSpread == 0) MaxSpread_pips = 3.5; //23:58~1:03不可
      
      else if (StringSubstr(AccountCompany(), 0, 11) == "ThreeTrader" // ThreeTrader
            && StringSubstr(Symbol(), 6, 4) == ".raw" // Raw口座
            && AllowSpread == 0) MaxSpread_pips = 3.0; //23:59~1:02不可
      
      else if (StringSubstr(AccountCompany(), 0, 8) == "Titan FX" // Titan FX
            && StringSubstr(AccountServer(), 8, 2) == "06" // ブレード口座
            && AllowSpread == 0) MaxSpread_pips = 4.0; //23:58~1:14不可
            
      else if (StringSubstr(AccountCompany(), 0, 8) == "Titan FX" // Titan FX
            && StringSubstr(AccountServer(), 8, 2) == "03" // スタンダード口座
            && AllowSpread == 0) MaxSpread_pips = 5.5; //0:00~1:05不可
      
      else if (StringSubstr(AccountCompany(), 0, 9) == "Tradexfin" // XM Trading
            && StringLen(Symbol()) == 6 // スタンダード口座 
            && AllowSpread == 0) MaxSpread_pips = 6.0; //23:56~1:02不可
      
      else if (StringSubstr(AccountCompany(), 0, 9) == "Tradexfin" // XM Trading
            && StringSubstr(Symbol(), 6, 1) == "#" // 極口座
            && AllowSpread == 0) MaxSpread_pips = 3.5; //23:59~1:11不可
      
      else
      MaxSpread_pips = AllowSpread;
   }
   
   
//+-----------------------------------------------------------------+
// 開発モード（販売時はfalseに）
   if (Development) HideTestIndicators(false);// 使用しているインジケータを表示する
   else HideTestIndicators(true);// 使用しているインジケータを非表示にする
//+------------------------------------------------------------------+   
   
   return(0);
}
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
{
   // サマータイム調整・時間制御
   GetSummertimeShift();
   
   // ポジションをクローズ
   PositionClose();
   
   // トレーリング
   Trailing();
   
   // ポジションのエントリー
   PositionOpen();
   
   // TP, SLの再設定
   SetTPSL();
   
}
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
   Comment("");
}
//+------------------------------------------------------------------+

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

      //　GMT+9を基準に、どれだけずれているかを算出する------------------------
      MON = TimeMonth(TimeCurrent()); // 何月？
      SUN_day = TimeDay(TimeCurrent()) - TimeDayOfWeek(TimeCurrent()); // その週の日曜日は何日？
      
      if (Summertime == UK) // 英国式の場合
      {
         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 == US) // 米国式の場合
      {
         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を基準に
      xxGMT = GMT - 2 + summertime_shift;//GMT+2を基準に
      //GMT+9基準でどれだけずれているかを算出する（ココマデ）--------------------

//+------------------------------------------------------------------+
//| 時間制御                                                         |
//+------------------------------------------------------------------+      
      //---- トレード許可時間の判定 ----
      xTime = TimeHour(TimeCurrent()) - xGMT; // 日本時間
      xxTime = TimeHour(TimeCurrent()) - (GMT - 2); // サーバー時間（サマータイム計算なし）
      xxxTime = TimeHour(TimeCurrent()) - (GMT - 2 + summertime_shift); // サーバー時間（サマータイム計算あり）
      yTime = TimeMinute(TimeCurrent()); // サーバーの分
      gmtadjusted = TimeCurrent() - 60 * 60 * xGMT;
      xgmtadjusted = TimeCurrent() - 60 * 60 * xxGMT;
      AdjustedDay = TimeDay(xgmtadjusted); // 調整された日付を返す
      AdjustedWeek = TimeDayOfWeek(xgmtadjusted); // 調整された曜日を返す
      AdjustedMonth = TimeMonth(xgmtadjusted); // 調整された月を返す

      // 日本時間
      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;
      }
      
       // 週末ポジションクローズ
      if ((xTime == PositionClose_Time_W 
          && TimeDayOfWeek(gmtadjusted) == PositionClose_DayOfWeek1
          && WeekendClose == true)
         )
      {
         PositionClose = true;
      }
      else
      {
         PositionClose = false;
      }
      
      // エントリーNG時間
      if ( // 週末決済（日本時間）
            (xTime >= EntryNG_StartTime1 && xTime <= EntryNG_EndTime1 // 週末決済用（日本時間）
            && TimeDayOfWeek(gmtadjusted) >= EntryNG_DayOfWeek1 // 週末決済曜日（日本時間）
            && WeekendClose == true)
         )
      {
         GMT_Kadou_NG = true;
      }
      else
      {
         GMT_Kadou_NG = false;
      }
      
      // ロールオーバー・メンテナンス時間
      if (((xxTime == 23 && yTime >= 55 && TimeDayOfWeek(TimeCurrent()) != 5)
       || (xxTime == 23 && yTime >= 50 && TimeDayOfWeek(TimeCurrent()) == 5)
       || (xxTime == 0 && yTime <= 9))
       && ROMode == true)
      {
         ROTime = true;
      }
      else
      {
         ROTime = false;
      }
      
      // エントリーOK時間
      if (   (xxTime >= EntryOK_StartTime1 && xxTime <= EntryOK_EndTime1 && yTime < 50) // エントリー可能時間1（サーバー時間）
          || (xxTime >= EntryOK_StartTime2 && xxTime <= EntryOK_EndTime2 && yTime < 50)) // エントリー可能時間2（サーバー時間）
      {
         Logic1_Time = true;
      }
      else
      {
         Logic1_Time = false;
      }
      
      // エントリーNG時間
      if (xxTime >= Entry_NG_StartTime1 && xxTime < Entry_NG_EndTime1) // エントリー可能時間1（サーバー時間）
      {
         Logic1_NG_Time = true;
      }
      else
      {
         Logic1_NG_Time = false;
      }

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

//+------------------------------------------------------------------+
//| ポジションのクローズ                                             |
//+------------------------------------------------------------------+
void PositionClose()
{
   int i;
   double profit;
   bool res;
   
   //ローソク足始値のみ稼働（選択式）の場合、ココカラ
   if(Volume[0] <= 10 || xxTime == 0)
   {
   
      // 所有しているポジションをクローズする
      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;

            //int OrderOpenCandleCount = iBarShift(NULL, 0, OrderOpenTime()); // エントリーからのローソク足本数
         
         if (OrderType() == OP_BUY)
         {
            profit = Bid - OrderOpenPrice(); // 買いポジションだった場合の、含み損益を計算する
            
            // オーダーを成り行き決済する
            if 
            (ROTime == false && Logic1_NG_Time == false &&
               (
                (Exit2(false, profit) == 2 && Ask - Bid <= MaxSpread_pips * xpoint)
             || (Exit2(false, profit) == 2 && Ask - Bid > MaxSpread_pips * xpoint && profit > 0)
             || PositionClose == true // 週末ポジションクローズ
               //|| OrderOpenCandleCount >= CandleCloseHour * 12)
               )
            )
            {
               res = OrderClose(OrderTicket(), OrderLots(), Bid, NULL, Green);
               
               // ローソク足が一目均衡表の雲の中で決済されたらKumononaka_Exit = falseにしてエントリー制限用
               double c,  senkoua,  senkoub;

               // 先行スパンA＿B
               c = Close[1];
               senkoua = iIchimoku(NULL, Ichimoku_kumononaka_TIMEFRAMES, Ichimoku_kumononaka_tenkan, Ichimoku_kumononaka_kijun, Ichimoku_kumononaka_senkou, MODE_SENKOUSPANA, 1);
               senkoub = iIchimoku(NULL, Ichimoku_kumononaka_TIMEFRAMES, Ichimoku_kumononaka_tenkan, Ichimoku_kumononaka_kijun, Ichimoku_kumononaka_senkou, MODE_SENKOUSPANB, 1);

               if(c < MathMax(senkoua, senkoub) && c > MathMin(senkoua, senkoub))   //雲の内側にいるか確認
                 {
                  Kumononaka_Exit = false;  //true　エントリーできる ・　false　エントリーできない
                 } 
            }  
         }
   
         if (OrderType() == OP_SELL)
         {
            profit = OrderOpenPrice() - Ask; // 売りポジションだった場合の、含み損益を計算する

            // オーダーを成り行き決済する
            if 
            (ROTime == false && Logic1_NG_Time == false &&
               (
                (Exit1(true, profit) == 1 && Ask - Bid <= MaxSpread_pips * xpoint)
             || (Exit1(true, profit) == 1 && Ask - Bid > MaxSpread_pips * xpoint && profit > 0)
             || PositionClose == true
               //|| OrderOpenCandleCount >= CandleCloseHour * 12)
               )
            )
            {
               res = OrderClose(OrderTicket(), OrderLots(), Ask, NULL, Green);
               
               // ローソク足が一目均衡表の雲の中で決済されたらKumononaka_Exit = falseにしてエントリー制限用
               double c,  senkoua,  senkoub;

               // 先行スパンA＿B
               c = Close[1];
               senkoua = iIchimoku(NULL, Ichimoku_kumononaka_Sell_TIMEFRAMES, Ichimoku_kumononaka_Sell_tenkan, Ichimoku_kumononaka_Sell_kijun, Ichimoku_kumononaka_Sell_senkou, MODE_SENKOUSPANA, 1);
               senkoub = iIchimoku(NULL, Ichimoku_kumononaka_Sell_TIMEFRAMES, Ichimoku_kumononaka_Sell_tenkan, Ichimoku_kumononaka_Sell_kijun, Ichimoku_kumononaka_Sell_senkou, MODE_SENKOUSPANB, 1);

               if(c < MathMax(senkoua, senkoub) && c > MathMin(senkoua, senkoub))   //雲の内側にいるか確認
                 {
                  Kumononaka_Sell_Exit = false;  //true　エントリーできる ・　false　エントリーできない
                 }               
               
            }
         }

      } // 所有しているポジションをクローズする（ココマデ）
   } //ローソク足始値のみ稼働（ココマデ）
}
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| トレーリング                                                     |
//+------------------------------------------------------------------+
void Trailing()
{
   int i;
   double profit;
   bool res;
   double StopLevel = MarketInfo(Symbol(),MODE_STOPLEVEL) * (xpoint / 10);
   
   // トレーリングのローソク足始値のみ稼働（選択式）
   if((xxTime != 1 && Volume[0] <= 10) || (xxTime == 1 && yTime <= 2))
   {

      // 所有しているポジションのストップをトレールする
      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)
         {
            profit = NormalizeDouble(Bid - OrderOpenPrice(), Digits); // 買いポジションだった場合の、含み損益を計算する
            int HighestIndex = iHighest(NULL, PERIOD_M30, MODE_HIGH, CandleCheckCount, 1);
            int LowestIndex = iLowest(NULL, PERIOD_M30, MODE_LOW , CandleCheckCount, 1);
            double MostHigh = iHigh(NULL, PERIOD_M30, HighestIndex);
            double MostLow  =  iLow(NULL, PERIOD_M30, LowestIndex);
            double HLMargin_buy = MostHigh - MostLow;
            double TrailingStart_buy = HLMargin_buy * HLM_Per_TrailStart_buy / 100;
            double LowSL = iLow(NULL, 0, (iLowest(NULL, 0, MODE_LOW, BarCountSL_Trail_buy)));
            double SL_buy = MathMax(LowSL, OrderOpenPrice() + OOPMarginPips_buy * xpoint);
            TrailingStart_buy = NormalizeDouble(TrailingStart_buy, Digits);
            SL_buy = NormalizeDouble(SL_buy, Digits);
            
            // トレイルON、OFF
            if (Modify == true)
            {
               // 
               if (profit > TrailingStart_buy
               //&& Close[2] < Close[1]
               && NormalizeDouble(Bid - StopLevel, Digits) >= SL_buy
               && OrderStopLoss() < SL_buy
               && NormalizeDouble(OrderOpenPrice() + OOPMarginPips_buy * xpoint, Digits) <= SL_buy
               )
               {
                  res = OrderModify(OrderTicket(), 
                                    OrderOpenPrice(), 
                                    SL_buy,
                                    OrderTakeProfit(),
                                    0,
                                    MediumSeaGreen);
               }
            }
         }

         if (OrderType() == OP_SELL)
         {
            profit = NormalizeDouble(OrderOpenPrice() - Ask, Digits); // 売りポジションだった場合の、含み損益を計算する
            int HighestIndex_sell = iHighest(NULL, PERIOD_M30, MODE_HIGH, CandleCheckCount, 1);
            int LowestIndex_sell = iLowest(NULL, PERIOD_M30, MODE_LOW , CandleCheckCount, 1);
            double MostHigh_sell = iHigh(NULL, PERIOD_M30, HighestIndex_sell);
            double MostLow_sell  =  iLow(NULL, PERIOD_M30, LowestIndex_sell);
            double HLMargin_sell = MostHigh_sell - MostLow_sell;
            double TrailingStart_sell = HLMargin_sell * HLM_Per_TrailStart_sell / 100;
            double HighSL = iHigh(NULL, 0, (iHighest(NULL, 0, MODE_HIGH, BarCountSL_Trail_sell)));
            double SL_sell = MathMin(HighSL, OrderOpenPrice() - OOPMarginPips_sell * xpoint);
            TrailingStart_sell = NormalizeDouble(TrailingStart_sell, Digits);
            SL_sell = NormalizeDouble(SL_sell, Digits);
            
            // トレイルON、OFF
            if (Modify == true)
            {
               // 
               if (profit > TrailingStart_sell
               && NormalizeDouble(Ask + StopLevel, Digits) <= SL_sell
               && OrderStopLoss() > SL_sell
               && NormalizeDouble(OrderOpenPrice() - OOPMarginPips_sell * xpoint, Digits) >= SL_sell
               )
               {
                  res = OrderModify(OrderTicket(), 
                                    OrderOpenPrice(), 
                                    SL_sell,//OrderStopLoss() - ModifyStep_sell,
                                    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((xxTime != 1 && Volume[0] <= 50) || (xxTime == 1 && yTime <= 2))
   {
   
      // ポジションの数をカウントする
      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;
         }
      } // ポジションの数をカウントする（ココマデ）
      
      // 最終エントリー・決済からのローソク足本数をカウントする（連続エントリー防止）
      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; // 一度最終決済を抽出したらループから抜ける
         }
      } // 最終エントリー・決済からのローソク足本数をカウントする（ココマデ）

      int HighestIndex = iHighest(NULL, PERIOD_M30, MODE_HIGH, CandleCheckCount, 1);
      int LowestIndex = iLowest(NULL, PERIOD_M30, MODE_LOW , CandleCheckCount, 1);
      double MostHigh = iHigh(NULL, PERIOD_M30, HighestIndex);
      double MostLow  =  iLow(NULL, PERIOD_M30, LowestIndex);
      double TP_buy = (MostHigh - MostLow) * HL_margin_Ex_mul_buy;
      double TP_sell = (MostHigh - MostLow) * HL_margin_Ex_mul_sell;
      
   // 証拠金不足・トレード許可チェック
   if (EquityCheck())
   {
   {
      // エントリー条件を確認し、成立していればエントリーを行う
      if (Entry(true) == 1 // 買いエントリー
         //&& CountSell == 0
         && CountBuy < Maxposition
         && GMT_Kadou_NG == false
         && Logic1_Time == true
         && Buy_Entry == true)
      {
            ticket = OrderSend(Symbol(), 
                               OP_BUY, 
                               CalculateLots(MM_Risk, StopLoss_pips), 
                               Ask, 
                               Slippage, 
                               Ask - StopLoss_pips_buy * xpoint,
                               Ask + TP_buy,//TakeProfit_pips * xpoint, 
                               _Comment,
                               MagicNumber,
                               0,
                               Blue);
         // エントリーが失敗であれば、TPSLを分割して注文する
         if (ticket == -1)
         {
            ticket = OrderSend(Symbol(), 
                               OP_BUY, 
                               CalculateLots(MM_Risk, StopLoss_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_buy * xpoint,
                                    OrderOpenPrice() + TP_buy,//TakeProfit_pips * xpoint,
                                    0,
                                    MediumSeaGreen);

               }
            }
         }
      }
      
      else if (Entry(false) == 2 // 売りエントリー
              //&& CountBuy == 0
              && CountSell < Maxposition 
              && GMT_Kadou_NG == false
              && Logic1_Time == true
              && Sell_Entry == true)
      {
            ticket = OrderSend(Symbol(), 
                               OP_SELL, 
                               CalculateLots(MM_Risk, StopLoss_pips), 
                               Bid, 
                               Slippage, 
                               Bid + StopLoss_pips_sell * xpoint,
                               Bid - TP_sell,//TakeProfit_pips * xpoint, 
                               _Comment, 
                               MagicNumber, 
                               0, 
                               Red);
         // エントリーが失敗であれば、TPSLを分割して注文する
         if (ticket == -1)
         {
            ticket = OrderSend(Symbol(), 
                               OP_SELL, 
                               CalculateLots(MM_Risk, StopLoss_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_sell * xpoint,
                                    OrderOpenPrice() - TP_sell,//TakeProfit_pips * xpoint,
                                    0,
                                    MediumSeaGreen);
               }
            }
         }
      }
   }
   }
   } // エントリー判断のローソク足始値のみ稼働（ココマデ）
}
//+------------------------------------------------------------------+
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;
   
   // ポジションに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)
      {
         int HighestIndex = iHighest(NULL, PERIOD_M30, MODE_HIGH, CandleCheckCount, 1);
         int LowestIndex = iLowest(NULL, PERIOD_M30, MODE_LOW , CandleCheckCount, 1);
         double MostHigh = iHigh(NULL, PERIOD_M30, HighestIndex);
         double MostLow  =  iLow(NULL, PERIOD_M30, LowestIndex);
         double TP_buy = (MostHigh - MostLow) * HL_margin_Ex_mul_buy;
         TP_buy = NormalizeDouble(TP_buy, Digits);
         
         // TP, SLがどちらも設定されていなければ、TP, SLを設定する
         if (OrderStopLoss() == 0 && OrderTakeProfit() == 0)
         {
            res = OrderModify(OrderTicket(), 
                           OrderOpenPrice(), 
                           OrderOpenPrice() - StopLoss_pips_buy * xpoint,//SL_buy,
                           OrderOpenPrice() + TP_buy,//TakeProfit_pips * xpoint,
                           0,
                           MediumSeaGreen);
         }
      }

      // 売りポジションの場合
      if (OrderType() == OP_SELL)
      {
         int HighestIndex = iHighest(NULL, PERIOD_M30, MODE_HIGH, CandleCheckCount, 1);
         int LowestIndex = iLowest(NULL, PERIOD_M30, MODE_LOW , CandleCheckCount, 1);
         double MostHigh = iHigh(NULL, PERIOD_M30, HighestIndex);
         double MostLow  =  iLow(NULL, PERIOD_M30, LowestIndex);
         double TP_sell = (MostHigh - MostLow) * HL_margin_Ex_mul_sell;
         TP_sell = NormalizeDouble(TP_sell, Digits);
         
         // TP, SLがどちらも設定されていなければ、TP, SLを設定する
         if (OrderStopLoss() == 0 && OrderTakeProfit() == 0)
         {
            res = OrderModify(OrderTicket(), 
                              OrderOpenPrice(), 
                              OrderOpenPrice() + StopLoss_pips_sell * xpoint,//SL_sell,
                              OrderOpenPrice() - TP_sell,//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)
                                    && (Entry_Filter8(isbuy) == 1 || Entry_Filter8(isbuy) == 3)
                                    && (Entry_Filter9(isbuy) == 1 || Entry_Filter9(isbuy) == 3)
                                    && (Entry_Filter10(isbuy) == 1 || Entry_Filter10(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)
                                    && (Entry_Filter8(isbuy) == 2 || Entry_Filter8(isbuy) == 3)
                                    && (Entry_Filter9(isbuy) == 2 || Entry_Filter9(isbuy) == 3)
                                    && (Entry_Filter10(isbuy) == 2 || Entry_Filter10(isbuy) == 3)
           )
   {
      return(2);
   }
   else
   {
      return(0);
   }
}
//+------------------------------------------------------------------+

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

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

//+------------------------------------------------------------------+
//| エントリールール1                                                |
//+------------------------------------------------------------------+
int Entry_Rule1(bool isbuy)
{
   //エントリールール1
   //短期移動平均線が長期移動平均線の上にいる間は「買い」
   double MA1 = iMA(NULL, MA_Perfect_Order_TIMEFRAMES, MA_Perfect_Order_period1, 0, MODE_SMA, PRICE_CLOSE, 1);
   double MA2 = iMA(NULL, MA_Perfect_Order_TIMEFRAMES, MA_Perfect_Order_period2, 0, MODE_SMA, PRICE_CLOSE, 1);
   
   //短期移動平均線が長期移動平均線の上にいる間は「買い」
   if ( MA1 > MA2)
   {
      return(1);
   } // 買い

   else
   {
      return(0);
   }
   
   //エントリールール1を差し替える時は、ココマデを差し替えて下さい。
}
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| エントリーフィルター1                                            |
//+------------------------------------------------------------------+
int Entry_Filter1(bool isbuy)
{
   //エントリーフィルター1
   // 固定仕様系フィルター
// スプレッドフィルター
   double spread = MarketInfo(NULL, MODE_SPREAD);

   if(Digits == 3 || Digits == 5)
      spread /= 10.0;
   if(spread > MaxSpread_pips)
      return(0); // スプレッドが指定pips以上でトレード不許可
   
// ギャップフィルター
   double Close0 = iClose(NULL, 0, 0);
   double Close1 = iClose(NULL, 0, 1);
   if (xxTime != 1 && MathAbs(Close0 - Close1) >= Gap_Pips * xpoint) return(0);
   if (xxTime == 1 && MathAbs(Close0 - Close1) >= Gap_Pips_1 * xpoint) return(0);

// 年末年始フィルター：12/20~1/3まではエントリーしない
   int NGMonth = Month();
   int NGDay = Day();
   if (YearendClose == true
      && ((NGMonth == 12 && NGDay >= 20) || (NGMonth == 1 && NGDay <= 3))
      )
   {
      return(0);
   } // エントリー出来ない
   
   //エントリーフィルター1ココマデ
   return(3);
}
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| エントリーフィルター2                                           |
//+------------------------------------------------------------------+
int Entry_Filter2(bool isbuy)
{
   //エントリーフィルター2
   //ATRが指定値以下の時のみエントリー出来る
   double ATR = iATR(NULL, ATR_TIMEFRAMES, ATR_Period, 1);     // フィルターのみ M15 0.005(0.005)1.1  M30_0.05(0.02)1  H1_0.1(0.02)1  H4_0.2(0.05)1.5   D1_1(0.1)4.5
                                                               // 決済込み M15 0.05(0.02)1.1
   if (ATR <= ATR_Filter_Line)   
   {
      return(1);
   } // エントリー出来る
   else
   {
      return(0);
   } // エントリー出来ない

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

//+------------------------------------------------------------------+
//| エントリーフィルター3                                            |
//+------------------------------------------------------------------+
int Entry_Filter3(bool isbuy)
{
   //エントリーフィルター3
   // ストキャスティックスが指定値以上にいる間は「買い」、指定値以下にいる間は「売り」
   // %Dラインを使う時は下記のisUseSlowD=falseに、slow%Dラインを使う時はisUseSlowD=trueにして下さい。
   bool isUseSLowD=true;
   double Stochastic1;
   
   if (isUseSLowD)         //10(10)200  10(10)200 10(10)200 25(5)70
      Stochastic1 = iStochastic(NULL, Stochastic_TIMEFRAMES, PercentK_period, PercentD_period, Slow_period, MODE_SMA, 0, MODE_SIGNAL, 1); // slowDライン
   else
      Stochastic1 = iStochastic(NULL, Stochastic_TIMEFRAMES, PercentK_period, PercentD_period, Slow_period, MODE_SMA, 0, MODE_MAIN, 1); // %Dライン
   
   // ストキャスティックスが指定値以上にいる間は「買い」
   if (Stochastic1 > Stochastics_LINE)
   {
      return(1);
   } // 買い
   
   else
   {
      return(0);
   }


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

//+------------------------------------------------------------------+
//| エントリーフィルター4                                            |
//+------------------------------------------------------------------+
int Entry_Filter4(bool isbuy)
{
   //エントリーフィルター4
   // ローソク足が一目均衡表の雲の中で決済された後、1度雲の外に出たか確認
   double c,  senkoua,  senkoub;

// 先行スパンA＿B
   c = Close[1];
   senkoua = iIchimoku(NULL, Ichimoku_kumononaka_TIMEFRAMES, Ichimoku_kumononaka_tenkan, Ichimoku_kumononaka_kijun, Ichimoku_kumononaka_senkou, MODE_SENKOUSPANA, 1);
   senkoub = iIchimoku(NULL, Ichimoku_kumononaka_TIMEFRAMES, Ichimoku_kumononaka_tenkan, Ichimoku_kumononaka_kijun, Ichimoku_kumononaka_senkou, MODE_SENKOUSPANB, 1);

   if(Kumononaka_Exit == false)  //falseだったら if文 ・ trueだったらエントリーできる
     {
      if(c > MathMax(senkoua, senkoub) || c < MathMin(senkoua, senkoub))   //雲の外側にいるか確認
        {
         Kumononaka_Exit = true;  //true　エントリーできる ・　false　エントリーできない
         return(3);  //エントリーできる
        }
      else
        {
         return(0);  //エントリーできない
        }
     }

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

//+------------------------------------------------------------------+
//| エントリーフィルター5                                            |
//+------------------------------------------------------------------+
int Entry_Filter5(bool isbuy)
{
   //エントリーフィルター5
   // ADXが指定値以上の時のみエントリー出来る
   double ADX = iADX(NULL, ADX_TIMEFRAMES, ADX_Period, PRICE_CLOSE, MODE_MAIN, 1);       // 10(10)200  5(5)40  5(5)50
                                                                                           // 決済
   if (ADX >= ADX_Filter_Line)
   {
      return(1);
   } // エントリー出来る
   
   else
   {
      return(0);
   } // エントリー出来ない

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

//+------------------------------------------------------------------+
//| エントリーフィルター6                                            |
//+------------------------------------------------------------------+
int Entry_Filter6(bool isbuy)
{
   //エントリーフィルター6
   // 長期移動平均線に対し短期移動平均線が、指定%以上、下に乖離したら「買い」
   double MA_1 = iMA(NULL, MA_Kairi_TIMEFRAMES, MA_Kairi_period1, 0, MODE_SMA, PRICE_CLOSE, 1);       // 10(10)200  0.2(0.2)10  0.2(0.2)10
   double MA_2 = iMA(NULL, MA_Kairi_TIMEFRAMES, MA_Kairi_period2, 0, MODE_SMA, PRICE_CLOSE, 1);         // 決済
   
   // 長期移動平均線に対し短期移動平均線が、指定%以上、下に乖離したら「買い」
   if (MA_1 < (MA_2 + Close[1] * MA_Kairi_Filter_percent / 100.0))
   {
      return(1);
   } // 買い
   
   else
   {
      return(0);
   }

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

//+------------------------------------------------------------------+
//| エントリーフィルター7                                            |
//+------------------------------------------------------------------+
int Entry_Filter7(bool isbuy)
{
   //エントリーフィルター7
   
   //エントリーフィルター7ココマデ
   return(3);
}
//+------------------------------------------------------------------+

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

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

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

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

//+------------------------------------------------------------------+
//| エントリーフィルター10                                            |
//+------------------------------------------------------------------+
int Entry_Filter10(bool isbuy)
{
   //エントリーフィルター10
   
   //エントリーフィルター10ココマデ
   return(3);
}
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| 決済ルール1                                                      |
//+------------------------------------------------------------------+
int Exit_Rule1(bool isbuy, double profit)
{
   // 決済ルール1
   //短期移動平均線が長期移動平均線の下にいる間は「売り」
   double MA1 = iMA(NULL, MA_Perfect_Order_TIMEFRAMES, MA_Perfect_Order_period1, 0, MODE_SMA, PRICE_CLOSE, 1);
   double MA2 = iMA(NULL, MA_Perfect_Order_TIMEFRAMES, MA_Perfect_Order_period2, 0, MODE_SMA, PRICE_CLOSE, 1);

   //短期移動平均線が長期移動平均線の下にいる間は「売り」
   if (MA1 < MA2)
   {
      return(2);
   } // 売り

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

//+------------------------------------------------------------------+
//| 決済ルール2                                                      |
//+------------------------------------------------------------------+
int Exit_Rule2(bool isbuy, double profit)
{
   // 決済ルール2
   //ATRが指定値以上の時決済
   double ATR = iATR(NULL, ATR_TIMEFRAMES, ATR_Exit_Period, 1);     // M15 0.005(0.005)1.1  M30_0.05(0.02)1  H1_0.1(0.02)1  H4_0.2(0.05)1.5   D1_1(0.1)4.5
   double ATR1 = iATR(NULL, ATR_TIMEFRAMES, ATR_Exit_Period, 2);    // フィルター // 決済込み M15 0.05(0.02)1.1
   
   if (ATR1 < ATR_Exit_Filter_Line && ATR >= ATR_Exit_Filter_Line)   
   {
      return(2);
   } // 売り
   else
   {
      return(0);
   } 

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

//+------------------------------------------------------------------+
//| 決済ルール3                                                      |
//+------------------------------------------------------------------+
int Exit_Rule3(bool isbuy, double profit)
{
   // 決済ルール3
   // ローソク足が一目均衡表の雲の中に入る又は貫通したら決済
   double c,  senkoua,  senkoub;
   double c1, senkoua1, senkoub1;


// 終値が雲の上から雲の中に入ると売買
   c = Close[1];
   senkoua = iIchimoku(NULL, Ichimoku_kumononaka_TIMEFRAMES, Ichimoku_kumononaka_tenkan, Ichimoku_kumononaka_kijun, Ichimoku_kumononaka_senkou, MODE_SENKOUSPANA, 1);
   senkoub = iIchimoku(NULL, Ichimoku_kumononaka_TIMEFRAMES, Ichimoku_kumononaka_tenkan, Ichimoku_kumononaka_kijun, Ichimoku_kumononaka_senkou, MODE_SENKOUSPANB, 1);
   c1 = Close[2];
   senkoua1 = iIchimoku(NULL, Ichimoku_kumononaka_TIMEFRAMES, Ichimoku_kumononaka_tenkan, Ichimoku_kumononaka_kijun, Ichimoku_kumononaka_senkou, MODE_SENKOUSPANA, 2);
   senkoub1 = iIchimoku(NULL, Ichimoku_kumononaka_TIMEFRAMES, Ichimoku_kumononaka_tenkan, Ichimoku_kumononaka_kijun, Ichimoku_kumononaka_senkou, MODE_SENKOUSPANB, 2);

// 2本前の終値が雲の上に出ており、1本前の終値が雲の中に入っている又は雲の下まで貫通したら決済
   if((c1 >= MathMax(senkoua1, senkoub1) && c < MathMax(senkoua, senkoub) && c > MathMin(senkoua, senkoub)) 
   || (c1 >= MathMax(senkoua1, senkoub1) && c < MathMax(senkoua, senkoub) && c < MathMin(senkoua, senkoub)))


     {
      return(2);
     } // 売り

      else
        {
         return(0);
        }

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

//+------------------------------------------------------------------+
//| 決済ルール4                                                      |
//+------------------------------------------------------------------+
int Exit_Rule4(bool isbuy, double profit)
{
   // 決済ルール4
   // ストキャスティックスが指２本前が指定値以上、１本前が指定値以下にいる間は「売り」
   // %Dラインを使う時は下記のisUseSlowD=falseに、slow%Dラインを使う時はisUseSlowD=trueにして下さい。
   bool isUseSLowD=true;
   double Stochastic1;
   double Stochastic2;
   
   if (isUseSLowD)         //10(10)200  10(10)200 10(10)200 25(5)70
      Stochastic1 = iStochastic(NULL, Stochastic_TIMEFRAMES, PercentK_period, PercentD_period, Slow_period, MODE_SMA, 0, MODE_SIGNAL, 1); // slowDライン
      
   else
      Stochastic1 = iStochastic(NULL, Stochastic_TIMEFRAMES, PercentK_period, PercentD_period, Slow_period, MODE_SMA, 0, MODE_MAIN, 1); // %Dライン
      //Print("Stochastic1 1549 = ",Stochastic1);
      
   if (isUseSLowD)         //10(10)200  10(10)200 10(10)200 25(5)70
      Stochastic2 = iStochastic(NULL, Stochastic_TIMEFRAMES, PercentK_period, PercentD_period, Slow_period, MODE_SMA, 0, MODE_SIGNAL, 2); // slowDライン
   else
      Stochastic2 = iStochastic(NULL, Stochastic_TIMEFRAMES, PercentK_period, PercentD_period, Slow_period, MODE_SMA, 0, MODE_MAIN, 2); // %Dライン
      
   // ストキャスティックスが２本前が指定値以上、１本前が指定値以下にいる間は「売り」
   if (Stochastic2 >= Stochastics_Exit_LINE && Stochastic1 < Stochastics_Exit_LINE)
   {
      return(2);
   } // 売り
   
   else
   {
      return(0);
   }


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

//+------------------------------------------------------------------+
//| 決済ルール5                                                      |
//+------------------------------------------------------------------+
int Exit_Rule5(bool isbuy, double profit)
{
   // 決済ルール5
   // ADX 上から決済ラインを下抜けしたら決済
   double ADX = iADX(NULL, ADX_TIMEFRAMES, ADX_Period, PRICE_CLOSE, MODE_MAIN, 1);       // 10(10)200  5(5)40  5(5)50
   double ADX1 = iADX(NULL, ADX_TIMEFRAMES, ADX_Period, PRICE_CLOSE, MODE_MAIN, 2);        // フィルター
   
   if (ADX1 > ADX_Exit_Line && ADX <= ADX_Exit_Line)
   {
      return(2);
   } // 売り
   
   else
   {
      return(0);
   }

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

//+------------------------------------------------------------------+
//| 決済ルール6                                                      |
//+------------------------------------------------------------------+
int Exit_Rule6(bool isbuy, double profit)
{
   // 決済ルール6
   // 長期移動平均線に対し短期移動平均線が、指定%以上、下に乖離したら「買い」。
   double MA_1 = iMA(NULL, MA_Kairi_TIMEFRAMES, MA_Kairi_period1, 0, MODE_SMA, PRICE_CLOSE, 1);       // 10(10)200  0.2(0.2)10  0.2(0.2)10
   double MA_2 = iMA(NULL, MA_Kairi_TIMEFRAMES, MA_Kairi_period2, 0, MODE_SMA, PRICE_CLOSE, 1);         // フィルター
   
   // 長期移動平均線に対し短期移動平均線が、指定%以上、上に乖離したら「買い」
   if (MA_1 > (MA_2 + Close[1] * MA_Kairi_Exit_percent / 100.0))
   {
      return(2);
   } // 売り
   
   else
   {
      return(0);
   }

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

//+------------------------------------------------------------------+
//| 決済ルール7                                                      |
//+------------------------------------------------------------------+
int Exit_Rule7(bool isbuy, double profit)
{
   // 決済ルール7

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

//+------------------------------------------------------------------+
//| 決済ルール8                                                      |
//+------------------------------------------------------------------+
int Exit_Rule8(bool isbuy, double profit)
{
   // 決済ルール8

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

//+------------------------------------------------------------------+
//| 決済ルール9                                                      |
//+------------------------------------------------------------------+
int Exit_Rule9(bool isbuy, double profit)
{
   // 決済ルール9
   
   
   // 決済ルール9ココマデ
   return(3);
}
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| 決済ルール10                                                      |
//+------------------------------------------------------------------+
int Exit_Rule10(bool isbuy, double profit)
{
   // 決済ルール10
   
   
   // 決済ルール10ココマデ
   return(3);
}
//+------------------------------------------------------------------+