/// <summary>
/// 期間情報更新
/// </summary>
/// <param name="data"></param>
private void updateTerm(ChallengeSelect.EventData data)
{
if (TimeEventManager.Instance.ChkEventActive(data.eventMaster.event_id) == true)
{
//開催中
MasterDataEvent eventData = MasterDataUtil.GetMasterDataEventFromID(data.eventMaster.event_id);
DateTime startTime = TimeUtil.GetDateTime(eventData.timing_start);
string kikanFormat = GameTextUtil.GetText("growth_boss_01");
if (eventData.timing_end != 0)
{
DateTime endTime = TimeUtil.GetDateTime(eventData.timing_end);
endTime = endTime.SubtractAMinute();
m_ChallengeSelect.Time = string.Format(kikanFormat, startTime.ToString("yyyy/MM/dd(HH:mm)"), endTime.ToString("yyyy/MM/dd(HH:mm)"));
}
else
{
m_ChallengeSelect.Time = string.Format(kikanFormat, startTime.ToString("yyyy/MM/dd(HH:mm)"), "");
}
m_ChallengeSelect.IsActiveSkipButton = true;
m_ChallengeSelect.IsActiveOkButton = true;
MainMenuHeader.UnderMsgRequest(GameTextUtil.GetText("challenge_quest_marquee_open"));
}
else
{
//イベント終了
if (data.eventMaster.receiving_end != 0)
{
DateTime endTime = TimeUtil.GetDateTime(data.eventMaster.receiving_end);
endTime = endTime.SubtractAMinute();
string kikanFormat = GameTextUtil.GetText("growth_boss_02");
m_ChallengeSelect.Time = string.Format(kikanFormat, endTime.ToString("yyyy/MM/dd(HH:mm)"));
}
else
{
m_ChallengeSelect.Time = GameTextUtil.GetText("growth_boss_03");
}
m_ChallengeSelect.IsActiveSkipButton = false;
m_ChallengeSelect.IsActiveOkButton = false;
MainMenuHeader.UnderMsgRequest(GameTextUtil.GetText("challenge_quest_marquee_end"));
}
}
private void setupPoint()
{
if (UserDataAdmin.Instance.m_StructPlayer == null)
{
return;
}
List <ItemKeyContext> tmpList = new List <ItemKeyContext>();
PacketStructUseItem[] items = UserDataAdmin.Instance.m_StructPlayer.item_list;
// レコード追加
for (int id = 0; id < items.Length; id++)
{
//所持していない
if (items[id].item_cnt == 0)
{
continue;
}
//マスターに存在するか
MasterDataUseItem itemMaster = MasterFinder <MasterDataUseItem> .Instance.Find((int)items[id].item_id);
if (itemMaster == null)
{
continue;
}
//チケットかどうか
if (itemMaster.gacha_event_id == 0)
{
continue;
}
//対象の有効なガチャが存在する
MasterDataGacha gachaMaster = MasterDataUtil.GetActiveItemPointGachaMaster(itemMaster.fix_id);
if (gachaMaster == null)
{
continue;
}
//イベントマスター取得
MasterDataEvent eventMaster = MasterDataUtil.GetMasterDataEventFromID(itemMaster.gacha_event_id);
if (eventMaster == null)
{
continue;
}
//期間外
if (TimeEventManager.Instance.ChkEventActive(eventMaster.event_id) == false)
{
continue;
}
//ガチャチケット
ItemKeyContext _newTicket = new ItemKeyContext();
_newTicket.Category = ItemKeyContext.CategoryType.ScratchTicket;
_newTicket.Name = itemMaster.item_name;
_newTicket.Count = items[id].item_cnt.ToString();
_newTicket.setupIcon(itemMaster);
_newTicket.itemMaster = itemMaster;
_newTicket.DidSelectItemKey = OnSelectKey;
_newTicket.IsViewTime = false;
_newTicket.Time = "";
_newTicket.timing_end = eventMaster.timing_end;
if (eventMaster.timing_end != 0)
{
string timeFormat = GameTextUtil.GetText("common_expirationdate");
DateTime endTime = TimeUtil.GetDateTime(eventMaster.timing_end).SubtractAMinute();
_newTicket.Time = string.Format(timeFormat, endTime.ToString("yyyy/MM/dd (HH:mm)"));
_newTicket.IsViewTime = true;
m_Item.PointList.Add(_newTicket);
}
else
{
//期間が無限のチケットは最後に追加するので一時退避
tmpList.Add(_newTicket);
}
}
//期間でソート
m_Item.PointList.Sort((a, b) => (int)a.timing_end - (int)b.timing_end);
//友情ポイント・ユニットポイント追加
{
ItemKeyContext _newFP = new ItemKeyContext();
_newFP.Category = ItemKeyContext.CategoryType.FriendPoint;
_newFP.IconImage = ResourceManager.Instance.Load("friend_point_icon", ResourceType.Common);
_newFP.Name = GameTextUtil.GetText("common_text1");
_newFP.Count = UserDataAdmin.Instance.m_StructPlayer.have_friend_pt.ToString();
_newFP.IsViewTime = false;
_newFP.Time = "";
_newFP.DidSelectItemKey = OnSelectKey;
m_Item.PointList.Add(_newFP);
ItemKeyContext _newUP = new ItemKeyContext();
_newUP.Category = ItemKeyContext.CategoryType.UnitPoint;
_newUP.IconImage = ResourceManager.Instance.Load("mm_item_unitpoint", ResourceType.Common);
_newUP.Name = GameTextUtil.GetText("common_text2");
_newUP.Count = UserDataAdmin.Instance.m_StructPlayer.have_unit_point.ToString();
_newUP.IsViewTime = false;
_newUP.Time = "";
_newUP.DidSelectItemKey = OnSelectKey;
m_Item.PointList.Add(_newUP);
}
//期間が無限のチケット追加
m_Item.PointList.AddRange(tmpList);
}
public void GetMasterDataEventFromID()
{
MasterDataEvent resGetMasterDataEventFromID = MasterDataUtil.GetMasterDataEventFromID(unEventID);
Debug.Log("GetMasterDataEventFromID(" + unEventID + ") " + System.Text.RegularExpressions.Regex.Unescape(JsonMapper.ToJson(resGetMasterDataEventFromID)));
}
private void setupQuest()
{
m_QuestSelect.isEndShowList = false;
m_QuestSelect.QuestList.Clear();
m_questButtons.Clear();
if (m_SelectAreaIndex >= m_QuestSelect.EpisodeList.Count)
{
return;
}
EpisodeDataContext episodeData = m_QuestSelect.EpisodeList[m_SelectAreaIndex];
MasterDataArea areaMaster = episodeData.master;
if (areaMaster == null)
{
return;
}
List <MasterDataQuest2> quest2List = MasterFinder <MasterDataQuest2> .Instance.SelectWhere("where area_id = ?", areaMaster.fix_id);
quest2List.Sort((a, b) => (int)a.fix_id - (int)b.fix_id);
MasterDataQuest2[] quest2Array = quest2List.ToArray();
if (quest2Array == null)
{
return;
}
MainMenuParam.m_QuestStaminaAmend = (float)episodeData.amend.m_QuestSelectAreaAmendStamina / 100.0f;
//クエストリスト更新
{
uint _count = 0;
uint _notClearCount = 0;
bool bSkip = false;
for (int i = 0; i < quest2Array.Length; i++)
{
uint _index = _count;
MasterDataQuest2 _masterQuest2 = quest2Array[i];
if (_masterQuest2.active != MasterDataDefineLabel.BoolType.ENABLE)
{
continue;
}
if (_masterQuest2.story != 0 && _notClearCount != 0)
{
//未クリアクエスト以降のシナリオはスキップ
bSkip = true;
}
else if (_masterQuest2.story == 0 &&
!ServerDataUtil.ChkRenewBitFlag(ref UserDataAdmin.Instance.m_StructPlayer.flag_renew_quest_clear, quest2Array[i].fix_id))
{
//１つめの未クリアは表示
if (_notClearCount != 0)
{
bSkip = true;
}
_notClearCount++;
}
if (bSkip)
{
continue;
}
var model = new ListItemModel(_index);
model.OnClicked += () =>
{
SelectQuest(_index);
};
m_questButtons.Add(model);
QuestDataContext newQuest = new QuestDataContext(model);
newQuest.master = _masterQuest2;
newQuest.area_category_id = m_MasterAreaCategory.fix_id;
newQuest.boss = MasterDataUtil.GetGuerrillaBossParamFromQuestID(_masterQuest2.fix_id);
newQuest.m_QuestId = _index + 1;
if (_masterQuest2.story == 0)
{
newQuest.m_QuestType = QuestDataContext.ExecType.Quest2;
newQuest.IconLabel = GameTextUtil.GetText("questselect_text1");
{
//詳細情報テキスト差し替え
MasterDataQuestAppearance[] questAppearance = MasterFinder <MasterDataQuestAppearance> .Instance.SelectWhere("where area_category_id = ?", MainMenuParam.m_QuestSelectAreaCateID).ToArray();
if (questAppearance.IsNullOrEmpty() == false)
{
// newQuest.IconLabel = GameTextUtil.GetText(questAppearance[0].boss_text_key);
// テキストキーではなく直接テキストが入っている
newQuest.IconLabel = questAppearance[0].boss_text_key;
}
}
UnitIconImageProvider.Instance.Get(
_masterQuest2.boss_chara_id,
sprite => { newQuest.IconImage = sprite; });
}
else
{
newQuest.m_QuestType = QuestDataContext.ExecType.Event;
newQuest.IconLabel = GameTextUtil.GetText("questselect_text2");
newQuest.IconImage = ResourceManager.Instance.Load("storyicon");
}
string titleFormat = GameTextUtil.GetText("questselect_questname1");
if (newQuest.boss != null)
{
titleFormat = GameTextUtil.GetText("questselect_questname2");
}
newQuest.Title = string.Format(titleFormat, _masterQuest2.quest_name);
newQuest.Index = _index;
newQuest.SelectImage = m_SelectSprite;
// newQuest.BackGroundTexture = m_QuestSelect.BackGroundImage.texture;
newQuest.IsActivePoint = false;
switch (_masterQuest2.consume_type)
{
case 1: //スタミナ
newQuest.IsActivePoint = true;
newQuest.PointLabel = GameTextUtil.GetText("questselect_text3");
if (episodeData.amend.m_QuestSelectAreaAmendStamina == 100)
{
newQuest.m_Point = (uint)_masterQuest2.consume_value;
newQuest.Point = string.Format("{0}", _masterQuest2.consume_value);
}
else
{
uint point = (uint)((float)_masterQuest2.consume_value * ((float)episodeData.amend.m_QuestSelectAreaAmendStamina / 100.0f));
newQuest.m_Point = point;
newQuest.Point = string.Format(GameTextUtil.GetText("stmina_bahutext"), point);
}
//スコア倍率アップ
newQuest.AmendText = "";
if (_masterQuest2.story == 0 &&
_masterQuest2.consume_value != 0 &&
episodeData.amend.m_FlagAmendScore)
{
float score_rate = (float)episodeData.amend.m_QuestSelectAreaAmendScore / 100.0f;
newQuest.AmendText = string.Format("スコア {0:0.0}倍", score_rate);
}
break;
case 2: //Key
{
newQuest.IsActivePoint = true;
newQuest.m_Point = (uint)_masterQuest2.consume_value;
string strFormat = GameTextUtil.GetText("questselect_text5");
MasterDataQuestKey _keyMaster = MasterDataUtil.GetMasterDataQuestKeyFromAreaCategoryID(m_MasterAreaCategory.fix_id);
if (_keyMaster != null)
{
newQuest.PointLabel = string.Format(strFormat, _keyMaster.key_name);
}
newQuest.Point = string.Format("{0}", _masterQuest2.consume_value);
}
break;
case 3: //Ticket
newQuest.IsActivePoint = true;
newQuest.m_Point = (uint)_masterQuest2.consume_value;
newQuest.PointLabel = GameTextUtil.GetText("questselect_text4");
newQuest.Point = string.Format("{0}", _masterQuest2.consume_value);
break;
}
newQuest.SetFlag(quest2Array[i].fix_id);
m_QuestSelect.QuestList.Add(newQuest);
_count++;
}
//-------------------------------------------------
// イベントスケジュールがあるが検索
//-------------------------------------------------
MasterDataEvent eventMaster = MasterDataUtil.GetMasterDataEventFromID(areaMaster.event_id);
m_QuestSelect.m_EventMaster = eventMaster;
if (eventMaster != null &&
eventMaster.event_schedule_show == MasterDataDefineLabel.BoolType.ENABLE)
{
m_QuestSelect.IsViewDetailButton = true;
}
else
{
m_QuestSelect.IsViewDetailButton = false;
}
}
// View更新
foreach (var episodeButton in m_episodeButtons)
{
episodeButton.HideArrow();
}
// インジケーターを表示
if (LoadingManager.Instance != null)
{
LoadingManager.Instance.RequestLoadingStart(LOADING_TYPE.ASSETBUNDLE);
}
m_QuestSelect.Show(episodeData.masterDataAreaCategory.fix_id, () =>
{
foreach (var questButton in m_questButtons)
{
questButton.Appear();
}
foreach (var episodeButton in m_episodeButtons)
{
if (episodeButton.isSelected)
{
episodeButton.ShowArrow();
}
else
{
episodeButton.HideArrow();
}
}
//戻るボタン抑制解除
SetSuspendReturn(false);
StartCoroutine(WaitShowQuestList(() =>
{
m_QuestSelect.isEndShowList = true;
}));
}, () =>
{
// インジケーターを閉じる
if (LoadingManager.Instance != null)
{
LoadingManager.Instance.RequestLoadingFinish(LOADING_TYPE.ASSETBUNDLE);
}
});
}
//----------------------------------------------------------------------------
/*!
* @brief サイクル処理
* @note サイクルイベントを算出する
* @add Developer 2016/07/25 v360
*/
//----------------------------------------------------------------------------
private bool CreateEventCycle(MasterDataEvent cEvent)
{
bool bResult = true;
//--------------------------------
// エラーチェック
// イベント有効時間が、0の場合は処理しない
//--------------------------------
if (cEvent.cycle_active_hour == 0)
{
return(bResult);
}
// イベント期間用
uint unEventStart;
uint unEventEnd;
uint unEventEndTemp;
// イベントマスター
uint unDateType = cEvent.cycle_date_type; // サイクル：曜日
uint unCycleStart = cEvent.cycle_timing_start; // サイクル：開始時間
uint unCycleActive = cEvent.cycle_active_hour; // サイクル：有効時間
int nActiveEnd = (int)(unCycleStart + unCycleActive); // サイクル：開始時間+有効時間
// 処理日
int nYearNow = TimeManager.Instance.m_TimeNow.Year; // 現在：年
int nMonthNow = TimeManager.Instance.m_TimeNow.Month; // 現在：月
int nDayNow = TimeManager.Instance.m_TimeNow.Day; // 現在：日
DateTime cFirstDayOfMonth = new DateTime(nYearNow, nMonthNow, 1); // 現在：月初め
DateTime cLastDayOfMonth = cFirstDayOfMonth.AddMonths(1).AddDays(-1); // 現在：月終わり
//--------------------------------
// サイクル曜日を取得
// データ順：月火水木金土日空 →下位bit
//--------------------------------
bool[] abChkBitDayOfWeek = new bool[TimeUtil.BIT_DAY_OF_WEEK_MAX];
int nBitFlag = 0;
for (int bitNum = 0; bitNum < TimeUtil.BIT_DAY_OF_WEEK_MAX; ++bitNum)
{
nBitFlag = 1 << bitNum;
#if BUILD_TYPE_DEBUG
// デバッグ機能：未来のクエストも表示する（表示が重なったりするかも…）
if (DebugOption.Instance.featureQuest)
{
abChkBitDayOfWeek[bitNum] = true; //全ての曜日を表示する
}
#endif //BUILD_TYPE_DEBUG
//--------------------------------
// フラグチェック
//--------------------------------
if ((unDateType & nBitFlag) == 0)
{
continue;
}
abChkBitDayOfWeek[bitNum] = true;
}
//--------------------------------
// 前後一週間をチェック
//--------------------------------
int nWeekMax = TimeUtil.BIT_DAY_OF_WEEK_MAX - 1;
int nDayWeekBefore = nDayNow - nWeekMax;
int nDayWeekAfter = nDayNow + nWeekMax;
int nYearStart; // 開始：年
int nMonthStart; // 開始：月
int nDayStart; // 開始：日
int nSearchDayOfWeek; // 前後一週間の曜日検索用
DateTime cFirstDayOfLastMonth; // 開始：月初め
DateTime cLastDayOfLastMonth; // 開始：月終わり
for (int dayNum = nDayWeekBefore; dayNum < nDayWeekAfter; ++dayNum)
{
#region ==== 開始時間を算出 ====
//--------------------------------
// 初期化
//--------------------------------
nYearStart = nYearNow;
nMonthStart = nMonthNow;
nDayStart = dayNum;
cLastDayOfLastMonth = cLastDayOfMonth;
//--------------------------------
// 月跨ぎチェック
//--------------------------------
// 現在：月初めより前の場合
if (nDayStart < 1)
{
--nMonthStart;
//--------------------------------
// 年跨ぎチェック
//--------------------------------
// 年明けより前の場合
if (nMonthStart < 1)
{
--nYearStart;
nMonthStart = MONTH_MAX;
}
//--------------------------------
// 開始日設定(先月日)
//--------------------------------
cFirstDayOfLastMonth = new DateTime(nYearStart, nMonthStart, 1); // 開始：月初め
cLastDayOfLastMonth = cFirstDayOfLastMonth.AddMonths(1).AddDays(-1); // 開始：月終わり
nDayStart += cLastDayOfLastMonth.Day;
}
// 現在：月終わりより後の場合
else if (nDayStart > cLastDayOfMonth.Day)
{
++nMonthStart;
//--------------------------------
// 年跨ぎチェック
//--------------------------------
// 年末より後の場合
if (nMonthStart > MONTH_MAX)
{
++nYearStart;
nMonthStart = 1;
}
//--------------------------------
// 開始日設定(来月日)
//--------------------------------
cFirstDayOfLastMonth = new DateTime(nYearStart, nMonthStart, 1); // 開始：月初め
cLastDayOfLastMonth = cFirstDayOfLastMonth.AddMonths(1).AddDays(-1); // 開始：月終わり
nDayStart -= cLastDayOfMonth.Day;
}
//--------------------------------
// サイクル曜日チェック
//--------------------------------
nSearchDayOfWeek = TimeUtil.GetDayOfWeekToBitValue(nYearStart, nMonthStart, nDayStart);
if (abChkBitDayOfWeek[nSearchDayOfWeek] == false)
{
continue;
}
//--------------------------------
// 開始時間を設定
//--------------------------------
unEventStart = TimeUtil.GetDateTimeToValue(nYearStart, nMonthStart, nDayStart, (int)unCycleStart);
//--------------------------------
// 期間チェック
// 開始タイミング前の日程は、登録しない
//--------------------------------
if (unEventStart < cEvent.timing_start)
{
continue;
}
#endregion
#region ==== 終了時間を算出 ====
//--------------------------------
// 終了時間の日跨ぎチェック(開始時間+有効時間)
// ※24時で、翌日の0時のため「>=」としている
//--------------------------------
if (nActiveEnd >= DAY_TIME_MAX)
{
int nAddYear = 0; // 終了加算：年
int nAddMonth = 0; // 終了加算：月
int nAddDay = nActiveEnd / DAY_TIME_MAX; // 終了加算：日
int nHourEnd = nActiveEnd % DAY_TIME_MAX; // 終了加算：時
//--------------------------------
// 月跨ぎチェック(開始日+加算日)
//--------------------------------
int nDayEnd = nDayStart + nAddDay;
if (nDayEnd > cLastDayOfLastMonth.Day)
{
++nAddMonth;
nDayEnd %= cLastDayOfLastMonth.Day;
}
//--------------------------------
// 年跨ぎチェック(開催月+加算月)
//--------------------------------
int nMonthEnd = nMonthStart + nAddMonth;
if (nMonthEnd > MONTH_MAX)
{
++nAddYear;
nMonthEnd %= MONTH_MAX;
}
unEventEndTemp = TimeUtil.GetDateTimeToValue((nYearStart + nAddYear),
nMonthEnd, nDayEnd, nHourEnd);
}
else
{
// 日を跨がないので、開始時間+有効時間を終了時間とする
unEventEndTemp = unEventStart + unCycleActive;
}
//--------------------------------
// 終了時間を設定
//--------------------------------
unEventEnd = unEventEndTemp;
#endregion
//--------------------------------
// イベント期間判定(現在開催中)
//--------------------------------
if (TimeManager.Instance.CheckWithinTime(unEventStart, unEventEnd) == false)
{
//--------------------------------
// スケジュールに表示する場合
// 未来予定は、スケジュールでしか使用していない(v360)
//--------------------------------
if (cEvent.event_schedule_show == MasterDataDefineLabel.BoolType.ENABLE)
{
//--------------------------------
// サイクルイベントの終了時間が、
// イベント終了タイミングを越えている場合
//--------------------------------
if (cEvent.timing_end > 0 &&
unEventEnd > cEvent.timing_end)
{
// 登録しない
continue;
}
//--------------------------------
// イベント期間判定(未来開催)
//--------------------------------
if (TimeManager.Instance.CheckFurtureTime(unEventStart, unEventEnd) == true)
{
//--------------------------------
// 未来有効のサイクル情報を保存
//--------------------------------
m_TimeEventCycleFurtureParam[m_TimeEventFurtureInputed].Setup(cEvent.fix_id,
unEventStart,
unEventEnd,
cEvent.event_schedule_show);
//--------------------------------
// 未来有効のイベントなのでフラグ立て
//--------------------------------
m_TimeEventFurtureID[m_TimeEventFurtureInputed] = cEvent.event_id;
++m_TimeEventFurtureInputed;
if (EVENT_MAX <= m_TimeEventFurtureInputed)
{
// 末尾を消して、応急処置
--m_TimeEventFurtureInputed;
#if BUILD_TYPE_DEBUG
Debug.LogError("EventFurtureID Buffer Over!");
#endif // BUILD_TYPE_DEBUG
}
}
}
continue;
}
//--------------------------------
// 現在有効なサイクル情報を保存
//--------------------------------
m_TimeEventCycleParam[m_TimeEventActiveInputed].Setup(cEvent.fix_id,
unEventStart,
unEventEnd,
cEvent.event_schedule_show);
//--------------------------------
// 現在時がイベント期間内なのでフラグ立て
//--------------------------------
m_TimeEventActiveID[m_TimeEventActiveInputed] = cEvent.event_id;
++m_TimeEventActiveInputed;
if (EVENT_MAX <= m_TimeEventActiveInputed)
{
#if BUILD_TYPE_DEBUG
Debug.LogError("EventID Buffer Over!");
#endif // BUILD_TYPE_DEBUG
bResult = false;
break;
}
}
return(bResult);
}
public void updateEvents()
{
//--------------------------------
// 期間限定イベントのマスターデータを総当たりでチェック
//--------------------------------
MasterDataDefineLabel.BelongType nUserGroup = SystemUtil.GetUserGroup();
MasterDataEvent[] eventArray = MasterFinder <MasterDataEvent> .Instance.GetAll();
//MasterDataEvent[] eventArray = MasterFinder<MasterDataEvent>.Instance.SelectWhere(" where active = ? and event_id != 0 and ( user_group = ? OR user_group = ?) ", MasterDataDefineLabel.BoolType.ENABLE, MasterDataDefineLabel.BelongType.NONE, nUserGroup).ToArray();
int nMasterEventMax = eventArray.Length;
for (int num = 0; num < nMasterEventMax; ++num)
{
MasterDataEvent cEvent = eventArray[num];
/*sqlite対応*/
if (cEvent.active != MasterDataDefineLabel.BoolType.ENABLE ||
cEvent.event_id == 0)
{
continue;
}
if (cEvent.user_group != MasterDataDefineLabel.BelongType.NONE &&
cEvent.user_group != nUserGroup)
{
continue;
}
//if (cEvent.event_id == 0) continue;
//--------------------------------
// サイクル処理対応
// @add Developer 2016/07/25 v360
//--------------------------------
// 指定(従来通り)
if (cEvent.period_type == MasterDataDefineLabel.PeriodType.DESIGNATION)
{
//--------------------------------
// イベント期間判定
//--------------------------------
bool bCheckWithinTime = TimeManager.Instance.CheckWithinTime(
cEvent.timing_start
, cEvent.timing_end
);
#if BUILD_TYPE_DEBUG
// デバッグ機能：未来のクエストも表示する（表示が重なったりするかも…）
if (DebugOption.Instance.featureQuest &&
bCheckWithinTime == false
)
{
DateTime date_time_start = TimeUtil.GetDateTime(cEvent.timing_start);
if (date_time_start.CompareTo(DateTime.Now) >= 0)
{
bCheckWithinTime = true;
}
}
#endif //BUILD_TYPE_DEBUG
if (bCheckWithinTime == false)
{
continue;
}
//--------------------------------
// 現在時がイベント期間内なのでフラグ立て
//--------------------------------
m_TimeEventActiveID[m_TimeEventActiveInputed] = cEvent.event_id;
m_TimeEventActiveInputed++;
if (EVENT_MAX <= m_TimeEventActiveInputed)
{
Debug.LogError("EventID Buffer Over!");
break;
}
}
// サイクル
else if (cEvent.period_type == MasterDataDefineLabel.PeriodType.CYCLE)
{
//--------------------------------
// イベント期間判定
//--------------------------------
if (TimeManager.Instance.CheckWithinTime(cEvent.timing_start, cEvent.timing_end) == false)
{
//--------------------------------
// 未来日チェック
// スケジュール開催予定用に、サイクルデータを作成するため
//--------------------------------
if (TimeManager.Instance.CheckFurtureTime(cEvent.timing_start, cEvent.timing_end) == false)
{
continue;
}
// 各種情報を分解取得
int nStartYear = TimeUtil.GetDateTimeToYear(cEvent.timing_start); // 年
int nStartMonth = TimeUtil.GetDateTimeToMonth(cEvent.timing_start); // 月
int nStartDay = TimeUtil.GetDateTimeToDay(cEvent.timing_start); // 日
DateTime cTimeStartDay = new DateTime(nStartYear, nStartMonth, nStartDay, 0, 0, 0);
// 時間を考慮しない現在日を取得
DateTime cTmpTimeNow = TimeManager.Instance.m_TimeNow;
DateTime cTimeNowDay = new DateTime(cTmpTimeNow.Year, cTmpTimeNow.Month, cTmpTimeNow.Day, 0, 0, 0);
// 現在日から開催日までのTimeSpanを取得
TimeSpan cTimeSpan = cTimeStartDay - cTimeNowDay;
// 開催日まで一日よりある場合は登録しない
if (cTimeSpan.Days > 1)
{
continue;
}
}
//--------------------------------
// サイクルデータ作成
//--------------------------------
if (CreateEventCycle(cEvent) == false)
{
break;
}
}
}
}
public void addScoreInfo(PacketStructUserScoreInfo scoreInfo, MasterDataScoreEvent scoreEventMaster)
{
ScoreEventContext scoreEvent = new ScoreEventContext();
//スコア情報
scoreEvent.ScoreInfo = scoreInfo;
//タイトル
scoreEvent.Title = scoreEventMaster.title;
//期間
string timeFormat = GameTextUtil.GetText("score_time_format");
if (TimeEventManager.Instance.ChkEventActive(scoreEventMaster.event_id) == true)
{
//開催中
MasterDataEvent eventData = MasterDataUtil.GetMasterDataEventFromID(scoreEventMaster.event_id);
DateTime startTime = TimeUtil.GetDateTime(eventData.timing_start);
if (eventData.timing_end != 0)
{
DateTime endTime = TimeUtil.GetDateTime(eventData.timing_end);
endTime = endTime.SubtractAMinute();
scoreEvent.Time = string.Format(GameTextUtil.GetText("score_period"), startTime.ToString(timeFormat), endTime.ToString(timeFormat));
}
else
{
//終了期限なし
scoreEvent.Time = string.Format(GameTextUtil.GetText("score_period_infinite"), startTime.ToString(timeFormat), "");
}
scoreEvent.IsTimeEnd = false;
}
else
{
//イベント終了
if (scoreEventMaster.receiving_end != 0)
{
DateTime endTime = TimeUtil.GetDateTime(scoreEventMaster.receiving_end);
endTime = endTime.SubtractAMinute();
string kikanFormat = GameTextUtil.GetText("Score_period_01");
scoreEvent.TimeEnd = string.Format(kikanFormat, endTime.ToString(timeFormat));
}
else
{
scoreEvent.TimeEnd = GameTextUtil.GetText("Score_period_02");
}
scoreEvent.IsTimeEnd = true;
}
//エリア情報
scoreEvent.AreaMessage = GameTextUtil.GetText("score_notice");
//ハイスコア
scoreEvent.HiScoreLabel = GameTextUtil.GetText("score_subtitle_highscore");
scoreEvent.HiScore = string.Format(GameTextUtil.GetText("score_entity_01"), scoreInfo.hi_score);
scoreEvent.HiScorePt = GameTextUtil.GetText("score_entity_02");
//累積スコア
scoreEvent.TotalScoreLabel = GameTextUtil.GetText("score_subtitle_cumulative");;
scoreEvent.TotalScore = string.Format(GameTextUtil.GetText("score_entity_01"), scoreInfo.total_score);
scoreEvent.TotalScorePt = GameTextUtil.GetText("score_entity_02");
//報酬情報更新
updateScoreReward(scoreEvent, scoreInfo);
//アイコン
MasterDataPresent imagePresent = null;
if (scoreEventMaster.image_present_id != 0)
{
imagePresent = MasterDataUtil.GetPresentParamFromID(scoreEventMaster.image_present_id);
}
if (imagePresent != null)
{
MainMenuUtil.GetPresentIcon(imagePresent, (sprite) =>
{
scoreEvent.IconImage = sprite;
});
}
else
{
UnitIconImageProvider.Instance.Get(
1,
(sprite) =>
{
scoreEvent.IconImage = sprite;
});
}
scoreEvent.DidSelectItem = OnSelectItem;
EventList.Add(scoreEvent);
}
// ダイアログの初期化
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
}
private void CheckSkillUpEvent()
{
//----------------------------------------
// スキルレベルアップ確率上昇イベントの発生判定
//----------------------------------------
MasterDataEvent cHitEventMaster = null;
MainMenuParam.m_BlendBuildEventSLV = 0;
//--------------------------------
// スキルレベルアップ確率上昇イベントIDをリスト化
// @change Developer 2016/08/04 v360
//--------------------------------
uint[] aunEventSLVList =
{
GlobalDefine.SLV_EVENT_ID_x1000, // スキルレベルアップ確率増加イベントID：10.0倍
GlobalDefine.SLV_EVENT_ID_x0500, // スキルレベルアップ確率増加イベントID：5.0倍
GlobalDefine.SLV_EVENT_ID_x0400, // スキルレベルアップ確率増加イベントID：4.0倍
GlobalDefine.SLV_EVENT_ID_x0300, // スキルレベルアップ確率増加イベントID：3.0倍
GlobalDefine.SLV_EVENT_ID_x0250, // スキルレベルアップ確率増加イベントID：2.5倍
GlobalDefine.SLV_EVENT_ID_x0200, // スキルレベルアップ確率増加イベントID：2.0倍
GlobalDefine.SLV_EVENT_ID_x0150 // スキルレベルアップ確率増加イベントID：1.5倍
};
//--------------------------------
// イベント期間判定
// @add Developer 2016/08/04 v360
//--------------------------------
MasterDataEvent cTempEventMaster;
uint unTimingStart = 0;
uint unTimingEnd = 0;
uint unFixEndTime = 0;
for (int num = 0; num < aunEventSLVList.Length; ++num)
{
cTempEventMaster = MasterDataUtil.GetMasterDataEventFromID(aunEventSLVList[num]);
if (cTempEventMaster == null)
{
continue;
}
//--------------------------------
// 期間指定タイプによる分岐
//--------------------------------
switch (cTempEventMaster.period_type)
{
// 指定(従来通り)
default:
case MasterDataDefineLabel.PeriodType.DESIGNATION:
unTimingStart = cTempEventMaster.timing_start;
unTimingEnd = cTempEventMaster.timing_end;
break;
// サイクル
case MasterDataDefineLabel.PeriodType.CYCLE:
if (cHitEventMaster != null ||
TimeEventManager.Instance == null)
{
continue;
}
// 開催期間を取得
CycleParam cCycleParam = TimeEventManager.Instance.GetEventCycleParam(cTempEventMaster.event_id);
if (cCycleParam == null)
{
continue;
}
unTimingStart = cCycleParam.timingStart;
unTimingEnd = cCycleParam.timingEnd;
break;
}
//--------------------------------
// イベント期間判定
//--------------------------------
bool bCheckWithinTime = TimeManager.Instance.CheckWithinTime(unTimingStart, unTimingEnd);
if (bCheckWithinTime == false)
{
continue;
}
// 各種情報を設定
unFixEndTime = unTimingEnd; // イベント終了時間
cHitEventMaster = cTempEventMaster; // イベントマスター
// 従来通りならイベント判定終了(指定優先)
if (cTempEventMaster.period_type != MasterDataDefineLabel.PeriodType.CYCLE)
{
break;
}
}
//--------------------------------
// イベント終了時のフロー戻しがキツイので、
// やっぱりチュートリアル中はイベント開催を検知しない
//--------------------------------
if (TutorialManager.IsExists)
{
cHitEventMaster = null;
}
//-------------------------------
// イベント開催中か否かで表示分岐
// サイクル対応、無期限対応
// @change Developer 2016/08/04 v360
//-------------------------------
if (cHitEventMaster != null)
{
MainMenuParam.m_BlendBuildEventSLV = cHitEventMaster.event_id;
}
}
/// <summary>
/// 表示するイベント情報を取得する
/// </summary>
List <EventScheduleInfo> GetEvetntItemList(Category category)
{
List <EventScheduleInfo> eventItemList = new List <EventScheduleInfo>();
MasterDataArea[] areaMasterArray = MasterFinder <MasterDataArea> .Instance.GetAll();
for (int i = 0; i < areaMasterArray.Length; ++i)
{
MasterDataArea cAreaMasterData = areaMasterArray[i];
// イベント情報取得
MasterDataEvent cMasterDataEvent = null;
if (category == Category.Active)
{
//開催中ページの場合、有効なイベント情報取得
cMasterDataEvent = MasterDataUtil.GetMasterDataEventFromID(cAreaMasterData.event_id);
}
else
{
//開催予定ページの場合、開始日が未来日のイベント情報取得
cMasterDataEvent = MasterDataUtil.GetMasterDataFurtureEventFromID(cAreaMasterData.event_id);
}
//--------------------------------
//表示対象かをチェック
//--------------------------------
if (cMasterDataEvent == null)
{
continue;
}
uint unFixID = 0;
uint unTimingStart = 0;
uint unTimingEnd = 0;
MasterDataDefineLabel.BoolType unScheduleShow = MasterDataDefineLabel.BoolType.NONE;
//--------------------------------
// 期間指定タイプによる分岐
// @add Developer 2016/07/29 v360
//--------------------------------
switch (cMasterDataEvent.period_type)
{
// 指定(従来通り)
default:
case MasterDataDefineLabel.PeriodType.DESIGNATION:
unFixID = cMasterDataEvent.fix_id;
unTimingStart = cMasterDataEvent.timing_start;
unTimingEnd = cMasterDataEvent.timing_end;
unScheduleShow = cMasterDataEvent.event_schedule_show;
break;
// サイクル
case MasterDataDefineLabel.PeriodType.CYCLE:
if (TimeEventManager.Instance == null)
{
continue;
}
// エリアの表示期間のカウントダウンを算出
CycleParam cCycleParam;
if (category == Category.Active)
{
cCycleParam = TimeEventManager.Instance.GetEventCycleParam(cMasterDataEvent.event_id);
}
else
{
cCycleParam = TimeEventManager.Instance.GetEventCycleFurtureParam(cMasterDataEvent.event_id);
}
if (cCycleParam == null)
{
continue;
}
unFixID = cCycleParam.fixID;
unTimingStart = cCycleParam.timingStart;
unTimingEnd = cCycleParam.timingEnd;
unScheduleShow = cCycleParam.schedule;
break;
}
if (unScheduleShow != MasterDataDefineLabel.BoolType.ENABLE)
{
continue;
}
// 開催中ページの場合
if (category == Category.Active)
{
//--------------------------------
// イベント期間判定
//--------------------------------
bool bCheckWithinTime = TimeManager.Instance.CheckWithinTime(unTimingStart, unTimingEnd);
if (bCheckWithinTime == false)
{
continue;
}
}
// 開催予定ページの場合開始時間が現在日の次の日までを表示する
else if (category == Category.Furture)
{
// 時間を考慮しない開始日を取得
int nYear = TimeUtil.GetDateTimeToYear(unTimingStart);
int nMonth = TimeUtil.GetDateTimeToMonth(unTimingStart);
int nDay = TimeUtil.GetDateTimeToDay(unTimingStart);
DateTime cTimeStartDay = new DateTime(nYear, nMonth, nDay, 0, 0, 0);
// 時間を考慮しない現在日を取得
DateTime cTmpTimeNow = TimeManager.Instance.m_TimeNow;
DateTime cTimeNowDay = new DateTime(cTmpTimeNow.Year, cTmpTimeNow.Month, cTmpTimeNow.Day, 0, 0, 0);
// 現在日から開催日までのTimeSpanを取得
TimeSpan timeSpan = cTimeStartDay - cTimeNowDay;
// 開催日まで一日よりある場合は登録しない
if (timeSpan.Days > 1)
{
continue;
}
}
EventScheduleInfo cEventScheduleInfo = new EventScheduleInfo();
//--------------------------------
// マスターの情報をそのまま使うと、
// サイクルなどの処理で困るため、一部改変してスケジュールのマスタとする
//--------------------------------
cEventScheduleInfo.m_MasterDataEvent = new MasterDataEvent();
cEventScheduleInfo.m_MasterDataEvent.fix_id = unFixID;
cEventScheduleInfo.m_MasterDataEvent.active = cMasterDataEvent.active;
cEventScheduleInfo.m_MasterDataEvent.period_type = cMasterDataEvent.period_type;
cEventScheduleInfo.m_MasterDataEvent.cycle_date_type = cMasterDataEvent.cycle_date_type;
cEventScheduleInfo.m_MasterDataEvent.cycle_timing_start = cMasterDataEvent.cycle_timing_start;
cEventScheduleInfo.m_MasterDataEvent.cycle_active_hour = cMasterDataEvent.cycle_active_hour;
cEventScheduleInfo.m_MasterDataEvent.timing_start = unTimingStart;
cEventScheduleInfo.m_MasterDataEvent.timing_end = unTimingEnd;
cEventScheduleInfo.m_MasterDataEvent.user_group = cMasterDataEvent.user_group;
cEventScheduleInfo.m_MasterDataEvent.event_id = cMasterDataEvent.event_id;
cEventScheduleInfo.m_MasterDataEvent.event_schedule_show = unScheduleShow;
cEventScheduleInfo.m_MasterDataEvent.area_id = (int)cAreaMasterData.fix_id;
cEventScheduleInfo.m_AreaName = cAreaMasterData.area_name;
cEventScheduleInfo.m_AreaUrl = cAreaMasterData.area_url;
//リストに追加
eventItemList.Add(cEventScheduleInfo);
}
return(eventItemList);
}
