| | |
| | | public class FairyLeagueModel : Model, IAfterPlayerDataInitialize, IBeforePlayerDataInitialize, IPlayerLoginOk
|
| | | {
|
| | | public event Action OnRefreshFairyLeagueEvent;
|
| | | private FairyLeagueStage m_FairyLeagueStage = FairyLeagueStage.Prepare;
|
| | |
|
| | | FairyLeagueWeekTime currentWeekTime = new FairyLeagueWeekTime();
|
| | | FairyLeagueWeekTime nextWeekTime = new FairyLeagueWeekTime();
|
| | |
|
| | | FairyLeagueStage cacheLeagueStage = FairyLeagueStage.Prepare;
|
| | |
|
| | | public FairyLeagueStage fairyLeagueStage
|
| | | {
|
| | | get
|
| | | {
|
| | | if (StepRing())
|
| | | {
|
| | | return FairyLeagueStage.Over;
|
| | | }
|
| | | return m_FairyLeagueStage;
|
| | | return currentWeekTime.fairyLeagueStage;
|
| | | }
|
| | | }
|
| | |
|
| | | public int fairyLeagueRing
|
| | | {
|
| | | get
|
| | | {
|
| | | if (IsNextWeek)
|
| | | {
|
| | | return 0;
|
| | | }
|
| | | var _dayOfWeek = TimeUtility.ServerNow.DayOfWeek == DayOfWeek.Sunday ? 7 : (int)TimeUtility.ServerNow.DayOfWeek;
|
| | | if (_dayOfWeek < groupTimes[1].dayOfWeek || _dayOfWeek > resultTimes[1].dayOfWeek)
|
| | | {
|
| | | return 0;
|
| | | }
|
| | | else if (_dayOfWeek == groupTimes[1].dayOfWeek)
|
| | | {
|
| | | if (TimeUtility.ServerNow.Hour < groupTimes[1].startHour)
|
| | | {
|
| | | return 0;
|
| | | }
|
| | | else if (TimeUtility.ServerNow.Hour == groupTimes[1].startHour &&
|
| | | TimeUtility.ServerNow.Minute < groupTimes[1].startMinute)
|
| | | {
|
| | | return 0;
|
| | | }
|
| | | }
|
| | | return 1;
|
| | | return currentWeekTime.currentSession;
|
| | | }
|
| | | }
|
| | |
|
| | | public int OpenServerWeek
|
| | | {
|
| | | get;
|
| | | private set;
|
| | | }
|
| | | public int ringCnt
|
| | | {
|
| | | get;
|
| | | private set;
|
| | | }
|
| | |
|
| | | public bool IsNextWeek
|
| | | {
|
| | | get
|
| | | {
|
| | | if (TimeUtility.OpenWeekCnt >= OpenServerWeek)
|
| | | {
|
| | | var _dayOfWeek = TimeUtility.ServerNow.DayOfWeek == DayOfWeek.Sunday ? 7 : (int)TimeUtility.ServerNow.DayOfWeek;
|
| | | if (_dayOfWeek > resultTimes[1].dayOfWeek && _dayOfWeek <= 7)
|
| | | {
|
| | | return true;
|
| | | }
|
| | | return false;
|
| | | }
|
| | | else
|
| | | {
|
| | | return true;
|
| | | }
|
| | | return currentWeekTime.IsNextWeek;
|
| | | }
|
| | | }
|
| | |
|
| | | bool serverInited = false;
|
| | |
|
| | | FairyModel fairyModel { get { return ModelCenter.Instance.GetModel<FairyModel>(); } }
|
| | |
|
| | |
| | | {
|
| | | ParseConfig();
|
| | | m_JoinFairyLeagueRedpoint = new Redpoint(10704, 1070401);
|
| | | dataRequestDict.Add(FairyLeagueStage.Grouping, false);
|
| | | dataRequestDict.Add(FairyLeagueStage.Fight, false);
|
| | | dataRequestDict.Add(FairyLeagueStage.Over, false);
|
| | | TimeUtility.OnServerOpenDayRefresh += OnServerOpenDayRefresh;
|
| | | DTCA003_tagUniversalGameRecInfo.onGetUniversalGameInfo += OnGetUniversalGameInfo;
|
| | | PlayerDatas.Instance.PlayerDataRefreshInfoEvent += PlayerDataRefreshInfoEvent;
|
| | | StageManager.Instance.onStageLoadFinish += OnStageLoadFinish;
|
| | | GlobalTimeEvent.Instance.minuteEvent += MinuteEvent;
|
| | | TimeMgr.Instance.OnDayEvent += DayEvent;
|
| | | fairyLeagueHelp = new FairyLeagueHelp();
|
| | | }
|
| | |
|
| | | public override void UnInit()
|
| | | {
|
| | | DTCA003_tagUniversalGameRecInfo.onGetUniversalGameInfo -= OnGetUniversalGameInfo;
|
| | | GlobalTimeEvent.Instance.minuteEvent -= MinuteEvent;
|
| | | TimeMgr.Instance.OnDayEvent -= DayEvent;
|
| | | }
|
| | |
|
| | | public void OnBeforePlayerDataInitialize()
|
| | | {
|
| | | ClearFairyWarHelp();
|
| | | frontFairyList.Clear();
|
| | | fairyLeagueFairyId = 0;
|
| | | fairyLeagueFairyName = string.Empty;
|
| | | serverInited = false;
|
| | | }
|
| | |
|
| | | public void OnAfterPlayerDataInitialize()
|
| | | {
|
| | | for (int i = 0; i < fairyStages.Length; i++)
|
| | | {
|
| | | dataRequestDict[fairyStages[i]] = false;
|
| | | }
|
| | | TimeMgr.Instance.OnSyntonyEvent -= OnSyntonyEvent;
|
| | | TimeMgr.Instance.OnSyntonyEvent += OnSyntonyEvent;
|
| | | }
|
| | |
|
| | | public void OnPlayerLoginOk()
|
| | | {
|
| | | CheckFairyLeagueStage();
|
| | | ResetFairyLeagueTime();
|
| | | cacheLeagueStage = fairyLeagueStage;
|
| | | CheckFairyLeagueData();
|
| | | UpdateRedpoint();
|
| | | serverInited = true;
|
| | | }
|
| | |
|
| | | private void OnServerOpenDayRefresh()
|
| | | {
|
| | | CheckFairyLeagueStage();
|
| | | ResetFairyLeagueTime();
|
| | | }
|
| | |
|
| | | private void DayEvent()
|
| | | {
|
| | | ResetFairyLeagueTime();
|
| | | }
|
| | |
|
| | | private void MinuteEvent()
|
| | | {
|
| | | if (!(StageManager.Instance.CurrentStage is DungeonStage) || !serverInited)
|
| | | {
|
| | | return;
|
| | | }
|
| | | if (cacheLeagueStage != fairyLeagueStage)
|
| | | {
|
| | | cacheLeagueStage = fairyLeagueStage;
|
| | | if (cacheLeagueStage != FairyLeagueStage.Prepare)
|
| | | {
|
| | | CheckFairyLeagueData();
|
| | | }
|
| | | if (OnRefreshFairyLeagueEvent != null)
|
| | | {
|
| | | OnRefreshFairyLeagueEvent();
|
| | | }
|
| | | }
|
| | | }
|
| | |
|
| | | void ResetFairyLeagueTime()
|
| | | {
|
| | | }
|
| | |
|
| | | private void PlayerDataRefreshInfoEvent(PlayerDataRefresh _type)
|
| | |
| | | }
|
| | | }
|
| | |
|
| | | private void OnSyntonyEvent(TimeMgr.SyntonyType type)
|
| | | {
|
| | | if (type == TimeMgr.SyntonyType.FairyLeaugeStage)
|
| | | {
|
| | | CheckFairyLeagueStage();
|
| | | CheckFairyLeagueData();
|
| | | if (OnRefreshFairyLeagueEvent != null)
|
| | | {
|
| | | OnRefreshFairyLeagueEvent();
|
| | | }
|
| | | UpdateRedpoint();
|
| | | }
|
| | | }
|
| | | #region 配置
|
| | | public const int FAIRY_LEAGUE_DUNGEON = 31220;
|
| | | public const int FAIRY_LEAGUE_BATTLE = 68;
|
| | | public readonly int[] groupRingStates = new int[] { 11, 21 };
|
| | | public readonly int[] fightRingStates = new int[] { 12, 22 };
|
| | | public readonly int overRingStates = 99;
|
| | | public WeekTime[] groupTimes { get; private set; }
|
| | | public WeekTime[] fightTimes { get; private set; }
|
| | | public WeekTime[] resultTimes { get; private set; }
|
| | | public WeekTime overTime { get; private set; }
|
| | | public readonly WeekTime skipWeekTime = new WeekTime(1, 0, 0, 0, 0);
|
| | | public List<WeekTime> fairyLeagueWeekTimes = new List<WeekTime>();
|
| | | private string[] guideImgKeys;
|
| | | public string[] GuideImgKeys
|
| | | {
|
| | |
| | | return guideImgKeys;
|
| | | }
|
| | | }
|
| | | private readonly FairyLeagueStage[] fairyStages = new FairyLeagueStage[]
|
| | | {
|
| | | FairyLeagueStage.Grouping,
|
| | | FairyLeagueStage.Fight, FairyLeagueStage.Over
|
| | | };
|
| | |
|
| | | public int fairyWarResUpperLimit
|
| | | {
|
| | | get;
|
| | |
| | | public Dictionary<int, List<AwardItem>> finalWarAwardDict = new Dictionary<int, List<AwardItem>>();
|
| | | public Dictionary<int, List<AwardItem>> finalWarChampionAwardDict = new Dictionary<int, List<AwardItem>>();
|
| | | private Dictionary<int, float> crystalRateDict = new Dictionary<int, float>();
|
| | |
|
| | | FairyLeagueWeekTime fairyLeagueWeekTime = new FairyLeagueWeekTime();
|
| | | private void ParseConfig()
|
| | | {
|
| | | FuncConfigConfig cfg = Config.Instance.Get<FuncConfigConfig>("FamilyMatchGuide");
|
| | |
| | | {
|
| | | guideImgKeys = ConfigParse.GetMultipleStr(cfg.Numerical1);
|
| | | }
|
| | | ringCnt = groupRingStates.Length;
|
| | | groupTimes = new WeekTime[groupRingStates.Length];
|
| | | DungeonStateTimeConfig stateCfg = null;
|
| | | for (int i = 0; i < groupRingStates.Length; i++)
|
| | | var configs = Config.Instance.GetAllValues<DungeonStateTimeConfig>();
|
| | | for (int i = 0; i < configs.Count; i++)
|
| | | {
|
| | | stateCfg = DungeonStateTimeConfig.DungeonStateTime(FAIRY_LEAGUE_DUNGEON, groupRingStates[i]);
|
| | | if (stateCfg != null)
|
| | | {
|
| | | OpenServerWeek = stateCfg.OpenServerWeek;
|
| | | groupTimes[i] = new WeekTime(stateCfg.StartWeekday, stateCfg.StartHour,
|
| | | stateCfg.StartMinute, stateCfg.EndHour, stateCfg.EndMinute);
|
| | | fairyLeagueWeekTimes.Add(groupTimes[i]);
|
| | | }
|
| | | }
|
| | | fightTimes = new WeekTime[fightRingStates.Length];
|
| | | resultTimes = new WeekTime[fightRingStates.Length];
|
| | | for (int i = 0; i < fightRingStates.Length; i++)
|
| | | {
|
| | | stateCfg = DungeonStateTimeConfig.DungeonStateTime(FAIRY_LEAGUE_DUNGEON, fightRingStates[i]);
|
| | | if (stateCfg != null)
|
| | | {
|
| | | fightTimes[i] = new WeekTime(stateCfg.StartWeekday, stateCfg.StartHour,
|
| | | stateCfg.StartMinute, stateCfg.EndHour, stateCfg.EndMinute);
|
| | | fairyLeagueWeekTimes.Add(fightTimes[i]);
|
| | | resultTimes[i] = new WeekTime(stateCfg.StartWeekday, stateCfg.EndHour, stateCfg.EndMinute, 0, 0);
|
| | | fairyLeagueWeekTimes.Add(resultTimes[i]);
|
| | | }
|
| | | }
|
| | | stateCfg = DungeonStateTimeConfig.DungeonStateTime(FAIRY_LEAGUE_DUNGEON, overRingStates);
|
| | | overTime = new WeekTime(stateCfg.StartWeekday, stateCfg.StartHour,
|
| | | stateCfg.StartMinute, stateCfg.EndHour, stateCfg.EndMinute);
|
| | | fairyLeagueWeekTimes.Add(overTime);
|
| | | fairyLeagueWeekTimes.Sort(CompareTime);
|
| | |
|
| | | }
|
| | | cfg = Config.Instance.Get<FuncConfigConfig>("FamilyMatchResourcePoint");
|
| | | if (cfg != null)
|
| | | {
|
| | |
| | | return crystalRateDict.TryGetValue(_npcId, out _rate);
|
| | | }
|
| | | #endregion
|
| | | public void CheckFairyLeagueStage()
|
| | | {
|
| | | var _dayOfWeek = TimeUtility.ServerNow.DayOfWeek == DayOfWeek.Sunday ? 7 : (int)TimeUtility.ServerNow.DayOfWeek;
|
| | | if (IsNextWeek)
|
| | | {
|
| | | m_FairyLeagueStage = FairyLeagueStage.Prepare;
|
| | | return;
|
| | | }
|
| | | for (int i = 0; i < fairyLeagueWeekTimes.Count; i++)
|
| | | {
|
| | | var _weekTime = fairyLeagueWeekTimes[i];
|
| | | if (_dayOfWeek < _weekTime.dayOfWeek)
|
| | | {
|
| | | m_FairyLeagueStage = GetFairyLeagueStage(i);
|
| | | return;
|
| | | }
|
| | | if (_dayOfWeek == _weekTime.dayOfWeek)
|
| | | {
|
| | | if (TimeUtility.Hour < _weekTime.startHour)
|
| | | {
|
| | | m_FairyLeagueStage = GetFairyLeagueStage(i);
|
| | | return;
|
| | | }
|
| | | if (TimeUtility.Hour == _weekTime.startHour &&
|
| | | TimeUtility.Minute < _weekTime.startMinute)
|
| | | {
|
| | | m_FairyLeagueStage = GetFairyLeagueStage(i);
|
| | | return;
|
| | | }
|
| | | }
|
| | | }
|
| | | var _nowTime = new WeekTime(_dayOfWeek, TimeUtility.Hour, TimeUtility.Minute, 0, 0, TimeUtility.Second);
|
| | | TimeMgr.Instance.Register(TimeMgr.SyntonyType.FairyLeaugeStage,
|
| | | (float)(skipWeekTime - _nowTime).TotalSeconds);
|
| | | m_FairyLeagueStage = FairyLeagueStage.Prepare;
|
| | | }
|
| | | private FairyLeagueStage GetFairyLeagueStage(int _index)
|
| | | {
|
| | | var _dayOfWeek = TimeUtility.ServerNow.DayOfWeek == DayOfWeek.Sunday ? 7 : (int)TimeUtility.ServerNow.DayOfWeek;
|
| | | var _nowTime = new WeekTime(_dayOfWeek, TimeUtility.Hour, TimeUtility.Minute, 0, 0, TimeUtility.Second);
|
| | | TimeMgr.Instance.Register(TimeMgr.SyntonyType.FairyLeaugeStage,
|
| | | (float)(fairyLeagueWeekTimes[_index] - _nowTime).TotalSeconds);
|
| | | switch (_index)
|
| | | {
|
| | | case 0:
|
| | | return FairyLeagueStage.Prepare;
|
| | | case 1:
|
| | | case 4:
|
| | | return FairyLeagueStage.Grouping;
|
| | | case 2:
|
| | | case 5:
|
| | | return FairyLeagueStage.Fight;
|
| | | case 3:
|
| | | case 6:
|
| | | return FairyLeagueStage.Over;
|
| | | }
|
| | | return FairyLeagueStage.Prepare;
|
| | | }
|
| | | private int CompareTime(WeekTime x, WeekTime y)
|
| | | {
|
| | | if (x.dayOfWeek.CompareTo(y.dayOfWeek) != 0)
|
| | | {
|
| | | return x.dayOfWeek.CompareTo(y.dayOfWeek);
|
| | | }
|
| | | if (x.startHour.CompareTo(y.startHour) != 0)
|
| | | {
|
| | | return x.startHour.CompareTo(y.startHour);
|
| | | }
|
| | | return x.startMinute.CompareTo(y.startMinute);
|
| | | }
|
| | |
|
| | | #region 仙盟联赛副本
|
| | | public int[] fairyLeagueCrystals
|
| | | {
|
| | |
| | | onFairyLeagueBattleEvent();
|
| | | }
|
| | | UpdateRedpoint();
|
| | | for (int i = 0; i < fairyStages.Length; i++)
|
| | | {
|
| | | dataRequestDict[fairyStages[i]] = fairyStages[i] == fairyLeagueStage ? true : false;
|
| | | }
|
| | | }
|
| | | }
|
| | | public bool SelfFairyInBattle(out int _error)
|
| | |
| | | _ring = fairyLeagueStage == FairyLeagueStage.Fight || fairyLeagueStage == FairyLeagueStage.Over ? 1 - _ring : _ring;
|
| | | if (_ring == 1)
|
| | | {
|
| | | var _param = StringUtility.Contact(Language.Get(StringUtility.Contact("Weekday", groupTimes[_ring].dayOfWeek)),
|
| | | fightTimes[1].startHour.ToString("D2"), ":", fightTimes[1].startMinute.ToString("D2"));
|
| | | SysNotifyMgr.Instance.ShowTip("LeagueCannotGo1", _param);
|
| | | //var _param = StringUtility.Contact(Language.Get(StringUtility.Contact("Weekday", groupTimes[_ring].dayOfWeek)),
|
| | | // fightTimes[1].startHour.ToString("D2"), ":", fightTimes[1].startMinute.ToString("D2"));
|
| | | //SysNotifyMgr.Instance.ShowTip("LeagueCannotGo1", _param);
|
| | | }
|
| | | else
|
| | | {
|
| | | var _param = StringUtility.Contact(Language.Get("Next"), Language.Get(StringUtility.Contact("Weekday", groupTimes[_ring].dayOfWeek)),
|
| | | fightTimes[0].startHour.ToString("D2"), ":", fightTimes[0].startMinute.ToString("D2"));
|
| | | SysNotifyMgr.Instance.ShowTip("LeagueCannotGo2", _param);
|
| | | //var _param = StringUtility.Contact(Language.Get("Next"), Language.Get(StringUtility.Contact("Weekday", groupTimes[_ring].dayOfWeek)),
|
| | | // fightTimes[0].startHour.ToString("D2"), ":", fightTimes[0].startMinute.ToString("D2"));
|
| | | //SysNotifyMgr.Instance.ShowTip("LeagueCannotGo2", _param);
|
| | | }
|
| | | break;
|
| | | case 6:
|
| | |
| | | }
|
| | | }
|
| | |
|
| | | private Dictionary<FairyLeagueStage, bool> dataRequestDict = new Dictionary<FairyLeagueStage, bool>();
|
| | | public void CheckFairyLeagueData()
|
| | | {
|
| | | //if (dataRequestDict.ContainsKey(fairyLeagueStage) && !dataRequestDict[fairyLeagueStage])
|
| | | //{
|
| | | CA001_tagViewUniversalGameRec _pak = new CA001_tagViewUniversalGameRec();
|
| | | _pak.ViewType = (byte)FAIRY_LEAGUE_BATTLE;
|
| | | GameNetSystem.Instance.SendInfo(_pak);
|
| | | //}
|
| | | }
|
| | |
|
| | | public List<FairyLeagueBattleData> GetFairyLeague(int _ring, int _grade)
|
| | | {
|
| | | Dictionary<int, List<FairyLeagueBattleData>> dic = null;
|
| | |
| | | }
|
| | | #endregion
|
| | | }
|
| | | public struct WeekTime
|
| | |
|
| | | public class FairyLeagueWeekTime
|
| | | {
|
| | | public int dayOfWeek { get; private set; }
|
| | | public int startHour { get; private set; }
|
| | | public int startMinute { get; private set; }
|
| | | public int startSeconds { get; private set; }
|
| | | public int endHour { get; private set; }
|
| | | public int endMinute { get; private set; }
|
| | | public List<Ring> rings = new List<Ring>();
|
| | |
|
| | | public WeekTime(int _weekDay, int _startHour, int _startMinute, int _endHour, int _endMinute, int _startSeconds = 0)
|
| | | {
|
| | | dayOfWeek = _weekDay;
|
| | | startHour = _startHour;
|
| | | startMinute = _startMinute;
|
| | | startSeconds = _startSeconds;
|
| | | endHour = _endHour;
|
| | | endMinute = _endMinute;
|
| | | }
|
| | | public static TimeSpan operator -(WeekTime y, WeekTime x)
|
| | | {
|
| | | var _totalSeconds = 0;
|
| | | int i = x.dayOfWeek;
|
| | | for (i = x.dayOfWeek; i != y.dayOfWeek; i = i == 7 ? 1 : i + 1)
|
| | | {
|
| | | if (i == x.dayOfWeek)
|
| | | {
|
| | | _totalSeconds += (23 - x.startHour) * 3600 + (59 - x.startMinute) * 60 + 60 - x.startSeconds;
|
| | | }
|
| | | else
|
| | | {
|
| | | _totalSeconds += 24 * 3600;
|
| | | }
|
| | | }
|
| | | if (i == y.dayOfWeek)
|
| | | {
|
| | | if (x.dayOfWeek == i)
|
| | | {
|
| | | var _timeSpany = new TimeSpan(y.startHour, y.startMinute, y.startSeconds);
|
| | | var _timeSpanx = new TimeSpan(x.startHour, x.startMinute, x.startSeconds);
|
| | | _totalSeconds += (int)(_timeSpany.TotalSeconds - _timeSpanx.TotalSeconds);
|
| | | }
|
| | | else
|
| | | {
|
| | | _totalSeconds += y.startHour * 3600;
|
| | | }
|
| | | }
|
| | | return new TimeSpan(_totalSeconds * TimeSpan.TicksPerSecond);
|
| | | }
|
| | |
|
| | | private static WeekTime s_Now = new WeekTime();
|
| | | public static WeekTime Now
|
| | | public bool IsNextWeek
|
| | | {
|
| | | get
|
| | | {
|
| | | var _dayOfWeek = TimeUtility.ServerNow.DayOfWeek == DayOfWeek.Sunday ? 7 : (int)TimeUtility.ServerNow.DayOfWeek;
|
| | | s_Now.dayOfWeek = _dayOfWeek;
|
| | | s_Now.startHour = TimeUtility.Hour;
|
| | | s_Now.startMinute = TimeUtility.Minute;
|
| | | s_Now.startSeconds = TimeUtility.Second;
|
| | | return s_Now;
|
| | | return rings.Count == 0 || rings[rings.Count - 1].IsOver(TimeUtility.ServerNow);
|
| | | }
|
| | | }
|
| | |
|
| | | public FairyLeagueStage fairyLeagueStage
|
| | | {
|
| | | get
|
| | | {
|
| | | if (IsNextWeek)
|
| | | {
|
| | | return FairyLeagueStage.Prepare;
|
| | | }
|
| | | Ring ring;
|
| | | if (TryGetCurrentRing(out ring))
|
| | | {
|
| | | Session session;
|
| | | if (ring.TryGetSession(TimeUtility.ServerNow, out session))
|
| | | {
|
| | | Stage stage;
|
| | | if (session.TryGetStage(TimeUtility.ServerNow, out stage))
|
| | | {
|
| | | return stage.stage;
|
| | | }
|
| | | }
|
| | | }
|
| | | return FairyLeagueStage.Prepare;
|
| | | }
|
| | | }
|
| | |
|
| | | public int currentSession
|
| | | {
|
| | | get
|
| | | {
|
| | | Ring ring;
|
| | | if (TryGetCurrentRing(out ring))
|
| | | {
|
| | | return ring.currentSession;
|
| | | }
|
| | | return 0;
|
| | | }
|
| | | }
|
| | |
|
| | | public void AddStage(DungeonStateTimeConfig config)
|
| | | {
|
| | | |
| | | }
|
| | |
|
| | | public bool TryGetCurrentRing(out Ring ring)
|
| | | {
|
| | | ring = null;
|
| | | for (int i = 0; i < rings.Count; i++)
|
| | | {
|
| | | if (rings[i].InRing(TimeUtility.ServerNow))
|
| | | {
|
| | | ring = rings[i];
|
| | | return true;
|
| | | }
|
| | | }
|
| | | return false;
|
| | | }
|
| | |
|
| | | public class Ring
|
| | | {
|
| | | public List<Session> sessions = new List<Session>();
|
| | |
|
| | | public int currentSession
|
| | | {
|
| | | get
|
| | | {
|
| | | for (int i = 0; i < sessions.Count; i++)
|
| | | {
|
| | | if (sessions[i].InSession(TimeUtility.ServerNow))
|
| | | {
|
| | | return i;
|
| | | }
|
| | | }
|
| | | return 0;
|
| | | }
|
| | | }
|
| | |
|
| | | public bool InRing(DateTime time)
|
| | | {
|
| | | for (int i = 0; i < sessions.Count; i++)
|
| | | {
|
| | | if (sessions[i].InSession(time))
|
| | | {
|
| | | return true;
|
| | | }
|
| | | }
|
| | | return false;
|
| | | }
|
| | |
|
| | | public bool TryGetSession(DateTime time, out Session session)
|
| | | {
|
| | | session = null;
|
| | | for (int i = 0; i < sessions.Count; i++)
|
| | | {
|
| | | if (sessions[i].InSession(time))
|
| | | {
|
| | | session = sessions[i];
|
| | | return true;
|
| | | }
|
| | | }
|
| | | return false;
|
| | | }
|
| | |
|
| | | public bool IsOver(DateTime time)
|
| | | {
|
| | | bool allOver = true;
|
| | | for (int i = 0; i < sessions.Count; i++)
|
| | | {
|
| | | if (!sessions[i].IsOver(time))
|
| | | {
|
| | | allOver = false;
|
| | | break;
|
| | | }
|
| | | }
|
| | | return allOver;
|
| | | }
|
| | | }
|
| | |
|
| | | public class Session
|
| | | {
|
| | | public List<Stage> stages = new List<Stage>();
|
| | |
|
| | | public bool InSession(DateTime time)
|
| | | {
|
| | | for (int i = 0; i < stages.Count; i++)
|
| | | {
|
| | | if (stages[i].InStage(time))
|
| | | {
|
| | | return true;
|
| | | }
|
| | | }
|
| | | return false;
|
| | | }
|
| | |
|
| | | public bool TryGetStage(DateTime time,out Stage stage)
|
| | | {
|
| | | stage = default(Stage);
|
| | | for (int i = 0; i < stages.Count; i++)
|
| | | {
|
| | | if (stages[i].InStage(time))
|
| | | {
|
| | | stage = stages[i];
|
| | | return true;
|
| | | }
|
| | | }
|
| | | return false;
|
| | | }
|
| | |
|
| | | public bool IsOver(DateTime time)
|
| | | {
|
| | | var stage = stages.Find((x) =>
|
| | | {
|
| | | return x.stage == FairyLeagueStage.Over;
|
| | | });
|
| | | return stage.IsOver(time);
|
| | | }
|
| | |
|
| | | int Compare(Stage x, Stage y)
|
| | | {
|
| | | return x.stage.CompareTo(y.stage);
|
| | | }
|
| | | }
|
| | |
|
| | | public struct Stage
|
| | | {
|
| | | public FairyLeagueStage stage;
|
| | | public int dayOfWeek;
|
| | | public int startHour;
|
| | | public int endHour;
|
| | | public int startMinute;
|
| | | public int endMinute;
|
| | |
|
| | | public bool InStage(DateTime time)
|
| | | {
|
| | | var _dayOfWeek = time.DayOfWeek == DayOfWeek.Sunday ? 7 : (int)time.DayOfWeek;
|
| | | if (dayOfWeek != _dayOfWeek)
|
| | | {
|
| | | return false;
|
| | | }
|
| | | if (time.Hour < startHour || time.Hour > endHour)
|
| | | {
|
| | | return false;
|
| | | }
|
| | | if (time.Hour == startHour && time.Minute < startMinute)
|
| | | {
|
| | | return false;
|
| | | }
|
| | | if (time.Hour == endHour && time.Minute >= endMinute)
|
| | | {
|
| | | return false;
|
| | | }
|
| | | return true;
|
| | | }
|
| | |
|
| | | public bool IsOver(DateTime time)
|
| | | {
|
| | | if (InStage(time))
|
| | | {
|
| | | return false;
|
| | | }
|
| | | var _dayOfWeek = time.DayOfWeek == DayOfWeek.Sunday ? 7 : (int)time.DayOfWeek;
|
| | | if (_dayOfWeek > dayOfWeek)
|
| | | {
|
| | | return true;
|
| | | }
|
| | | if (dayOfWeek == _dayOfWeek)
|
| | | {
|
| | | if (time.Hour > endHour)
|
| | | {
|
| | | return true;
|
| | | }
|
| | | if (time.Hour == endHour && time.Minute >= endMinute)
|
| | | {
|
| | | return true;
|
| | | }
|
| | | }
|
| | | return false;
|
| | | }
|
| | | }
|
| | | }
|
| | |
|
| | | public enum FairyLeagueStage
|
| | | {
|
| | | Prepare,
|