// ダイアログの初期化
    public void Create(EventRecordListItemContex contex, bool _future)
    {
        EventId   = contex.EventId;
        FixId     = contex.FixId;
        IsFuture  = _future;
        QuestType = contex.questType;

        if (IsFuture)
        {
            LocalSaveEventNotification cEventNotification = LocalSaveManager.Instance.CheckFuncNotificationRequest((uint)FixId);
            if (cEventNotification != null)
            {
                IsOnNotif = cEventNotification.m_Push;
            }
        }

        MasterDataEvent eventMaster = MasterFinder <MasterDataEvent> .Instance.Find(FixId);

        if (eventMaster == null)
        {
#if BUILD_TYPE_DEBUG
            Debug.LogError("Eventがみつかりません fix_id: " + FixId);
#endif
            return;
        }

        // テキスト
        Title0       = "開催期間";
        Title1       = eventMaster.head_titel_1;
        Title2       = eventMaster.head_titel_2;
        OverviewText = eventMaster.head_text;

        //サイクルタイプで終了が設定されていない場合、規定文字列を表示
        if (eventMaster.period_type == MasterDataDefineLabel.PeriodType.CYCLE &&
            eventMaster.timing_end == 0)
        {
            DateText = GameTextUtil.GetText("schedule_text");
        }
        else
        {
            DateText = string.Format("{0}~{1}",
                                     EventSchedule.TimingFormat(eventMaster.timing_start),
                                     ((eventMaster.timing_end != 0 ? EventSchedule.TimingFormat(eventMaster.timing_end, true) : ""))); // イベント開催~終了まで
        }

        // メインイメージを読み込み
        MainImage = null;
        string bannerUrl = eventMaster.banner_img_url;
        if (bannerUrl.IsNullOrEmpty() == false)
        {
            bannerUrl = GlobalDefine.GetEventScheduleBannerUrl() + bannerUrl;

            WebResource.Instance.GetSprite(bannerUrl,
                                           (Sprite sprite) =>
            {
                MainImage = sprite;
            },
                                           () => { });
        }

        // 通知情報
        var notification = MasterDataUtil.GetMasterDataNotification(eventMaster.fix_id,
                                                                    ServerDataDefine.NOTIFICATION_TYPE.EVENT);
        if (notification == null)
        {
            notificationTitle = null;
            notificationBody  = null;
            notificationdelay = 0;
        }
        else
        {
            notificationTitle = notification.notification_title;
            notificationBody  = notification.notification_body;
            var delay = TimeUtil.GetDateTime(notification.timing_start) - TimeManager.Instance.m_TimeNow;
            notificationdelay = delay.Milliseconds;
        }

        // デバッグ用
        //OverviewText += "\n";

        // エリア情報
        AreaId = (uint)eventMaster.area_id;
        var areaMaster = MasterFinder <MasterDataArea> .Instance.FindAll();

        var areaCateId = areaMaster.Where(x => x.fix_id == AreaId).Select(x => x.area_cate_id).ToList();
        AreaCateId = areaCateId.Count() != 0 ? areaCateId[0] : 0;

        List <uint> bossUnits = new List <uint>();
        switch (QuestType)
        {
        case MasterDataDefineLabel.QuestType.NORMAL:
        {
            var questMaster = MasterFinder <MasterDataQuest2> .Instance.FindAll();

            bossUnits = questMaster.Where(x => x.area_id == AreaId).Select(x => x.boss_chara_id).ToList();
        }
        break;

        case MasterDataDefineLabel.QuestType.CHALLENGE:
        {
            var challengeMaster = MasterFinder <MasterDataChallengeQuest> .Instance.FindAll();

            bossUnits = challengeMaster.Where(x => x.area_id == AreaId).Select(x => x.boss_chara_id).ToList();
        }
        break;

        default:
            break;
        }

        // ゲリラボスユニット(複数)
        var guerrillaUnits = new List <uint>();
        var area_id_list   = new int[] { (int)AreaId };
        var serverApi      = ServerDataUtilSend.SendPacketAPI_GetGuerrillaBossInfo(area_id_list);

        // ゲリラボスユニット取得成功時の振る舞い
        serverApi.setSuccessAction(_data =>
        {
            var guerrilla = _data.GetResult <ServerDataDefine.RecvGetGuerrillaBossInfo>().result.guerrilla_boss_list;
            if (guerrilla != null)
            {
                for (int i = 0; i < guerrilla.Length; i++)
                {
                    for (int j = 0; j < guerrilla[i].boss_id_list.Length; j++)
                    {
                        guerrillaUnits.Add((uint)guerrilla[i].boss_id_list[j]);
                    }
                }
            }

            // 出現ユニット
            List <uint> units = new List <uint>();

            // ボス・ゲリラボスIDの結合
            units.AddRange(bossUnits);
            units.AddRange(guerrillaUnits);

            // ソート
            units.Sort();

            // 重複を削除
            List <uint> unique = units.Distinct().ToList();

            // バトルが無いクエストはユニットが出現しないので削除(設定:UnitID=0)
            unique.RemoveAll(x => x == 0);

            // 該当ユニットの追加
            for (int i = 0; i < unique.Count; i++)
            {
                var icon            = new CircleButtonListItemContex(i, unique[i]);
                icon.IsEnableSelect = false;
                Icons.Add(icon);

                // デバッグ用
                //OverviewText += i + ":" + "出現ユニットID[" + unique[i] + "]" + "\n";

                // レイアウト再構成
                m_LastUpdateCount = 5;
            }
        });

        // SendStartの失敗時の振る舞い
        serverApi.setErrorAction(_date =>
        {
#if BUILD_TYPE_DEBUG
            Debug.Log("MASTER_HASH_GET:Error");
#endif
        });

        // ゲリラボス取得API
        serverApi.SendStart();
    }
    //----------------------------------------------------------------------------
    //	@brief		ローカル通知登録
    //----------------------------------------------------------------------------
    private static void RegisterNotification()
    {
        //------------------------------------------------------------------------
        //	ローカル通知の有効無効
        //------------------------------------------------------------------------
        bool enable_notification = false;

        if (LocalSaveManager.Instance == null)
        {
            return;
        }


        LocalSaveOption cOption = LocalSaveManager.Instance.LoadFuncOption();

        enable_notification = (cOption.m_OptionNotification == (int)LocalSaveDefine.OptionNotification.ON);

        if (enable_notification == false)
        {
            return;
        }

        if (TimeManager.Instance == null)
        {
            return;
        }

        //------------------------------------------------------------------------
        //	ローカル通知の登録
        //------------------------------------------------------------------------
        int  delay       = 0;
        bool bSeisekiden = false;

        MasterDataNotification[] notification_param_array = null;
        if (MasterDataUtil.IsMasterDataNotification())
        {
            notification_param_array = MasterDataUtil.GetMasterDataNotification();
        }

        MasterDataNotification notification_param;

        if (notification_param_array.IsNullOrEmpty() == false)
        {
            // パッチテキスト(通知表示しない期間)取得 v360
            string sCancelS = Patcher.Instance.GetLocalNotificationCancelStart();
            string sCancelE = Patcher.Instance.GetLocalNotificationCancelEnd();

            // 通知文言があるやつ
            for (uint i = 0; i < notification_param_array.Length; i++)
            {
                notification_param = notification_param_array[i];
                if (notification_param == null)
                {
                    continue;
                }

                string d = notification_param.timing_start.ToString() + @"00";
                // string f = "yyyyMMddHHmm";
                string   f  = "yyyyMMddHHmm";
                DateTime dt = DateTime.ParseExact(d, f, null);


                TimeSpan ts = dt.Subtract(TimeManager.Instance.m_TimeNow);
                if (ts.TotalSeconds < 0)
                {
                    // 期限を過ぎたデータは消す MasterDataEvent.fix_idと同じ
                    LocalSaveManager.Instance.RemoveFuncNotificationRequest(notification_param.fix_id);

                    continue;
                }

                //プッシュ通知のタイプが設定でOFFになっているなら弾く
                if ((notification_param.notification_type == MasterDataDefineLabel.NotificationType.EVENT ||
                     notification_param.notification_type == MasterDataDefineLabel.NotificationType.CASINO ||
                     notification_param.notification_type == MasterDataDefineLabel.NotificationType.SEISEKIDEN) &&
                    cOption.m_NotificationEvent == (int)LocalSaveDefine.OptionNotificationEvent.OFF)
                {
                    continue;
                }
                if (notification_param.notification_type == MasterDataDefineLabel.NotificationType.SEISEKIDEN)
                {
                    //すでに聖石殿の通知をしていたらその後の聖石殿の通知は弾く
                    if (bSeisekiden == true)
                    {
                        continue;
                    }
                }

                if (sCancelS.IsNOTNullOrEmpty() && sCancelE.IsNOTNullOrEmpty())
                {
                    //イベント開始タイミングがプッシュ通知を表示しない期間内ならはじくv360
                    if (sCancelS.Length == f.Length && sCancelE.Length == f.Length)
                    {
                        //パッチ登録テキストはYYYYMMDDhhmm形式のためそのままdatetimeに変換
                        DateTime dtCancelS = DateTime.ParseExact(sCancelS, f, null);
                        DateTime dtCancelE = DateTime.ParseExact(sCancelE, f, null);
                        if ((dtCancelS != null && dtCancelS <= dt) &&
                            (dtCancelE != null && dtCancelE > dt))
                        {
                            // はじく
                            continue;
                        }
                    }
                }


                delay = (int)ts.TotalSeconds;

                string notification_title = notification_param.notification_title;
                string notification_body  = notification_param.notification_body;

                if (notification_param.type != (int)ServerDataDefine.NOTIFICATION_TYPE.GACHA)
                {
                    // イベント通知フラグをチェックする
                    LocalSaveEventNotification cNotification = LocalSaveManager.Instance.CheckFuncNotificationRequest(notification_param.fix_id);
                    if (cNotification != null)
                    {
                        // データが登録されている場合
                        if (cNotification.m_Push == false)
                        {
                            // 通知しないならそのまま戻る
                            continue;
                        }
                        else
                        {
                            // 通知する場合で、テキストデータが無い場合。
                            // 初期値を入れる
                            if (notification_body == null ||
                                notification_body.Length <= 0)
                            {
                                MasterDataEvent cEventData = MasterDataUtil.GetMasterDataEventFromFixID(cNotification.m_FixID);
                                if (cEventData != null)
                                {
                                    MasterDataArea cAreaData = MasterDataUtil.GetAreaParamFromEventID(cEventData.event_id);
                                    if (cAreaData != null)
                                    {
                                        // 紐づいているエリアを見る
                                        notification_title = GameTextUtil.GetText("LOCAL_NOTIFICATION_REQUEST_TITLE");
                                        notification_body  = string.Format(GameTextUtil.GetText("LOCAL_NOTIFICATION_REQUEST_MESSAGE"), cAreaData.area_name);
                                    }
                                    // 情報が無ければ飛ばさない
                                }
                            }
                        }
                    }
                }
                // テキストデータが存在するものだけ通知に出す
                if (notification_body != null &&
                    notification_body.Length > 0)
                {
                    PQDMLocalNotification.SendNotification(notification_title,
                                                           notification_body,
                                                           delay);
                    if (notification_param.notification_type == MasterDataDefineLabel.NotificationType.SEISEKIDEN)
                    {
                        bSeisekiden = true;
                    }
                }
            }
            // 通知情報を保存する
            LocalSaveManager.Instance.SaveFuncNotificationRequest();
        }

        #region ==== スタミナMAX ====
        PacketStructPlayer cPlayer = UserDataAdmin.Instance.m_StructPlayer;
        // スタミナが減少チェック
        // 通知設定チェック
        if (cPlayer != null &&
            m_StaminaNow < cPlayer.stamina_max &&
            cOption.m_NotificationStaminaMax == (int)LocalSaveDefine.OptionNotificationStaminaMax.ON)
        {
            //----------------------------------------
            // スタミナ回復シミュレート
            // 回復に関連する時間系データを算出
            //----------------------------------------
            DateTime cRecoveryTime   = TimeUtil.ConvertServerTimeToLocalTime(cPlayer.stamina_recover);  // 開始時刻取得
            uint     unRecoveryValue = cPlayer.stamina_max - m_StaminaNow;                              // スタミナ回復量取得

            // 終了時刻算出
            cRecoveryTime = cRecoveryTime.AddSeconds(GlobalDefine.STAMINA_RECOVERY_SEC * unRecoveryValue);

            //----------------------------------------
            // ローカル通知設定
            //----------------------------------------
            TimeSpan ts = cRecoveryTime.Subtract(TimeManager.Instance.m_TimeNow);
            if (ts.TotalSeconds >= 0)
            {
                delay = (int)ts.TotalSeconds;
                PQDMLocalNotification.SendNotification(UnityUtil.GetText("LOCAL_NOTIFICATION_STAMINA_TITLE"),
                                                       UnityUtil.GetText("LOCAL_NOTIFICATION_STAMINA_MESSAGE"),
                                                       delay);
            }
        }
        #endregion
    }