//--------------------------------------------------------
|
// [Author]: 第二世界
|
// [ Date ]: Saturday, September 16, 2017
|
//--------------------------------------------------------
|
using UnityEngine;
|
using System.Collections;
|
using System.Collections.Generic;
|
|
using System;
|
|
namespace Snxxz.UI
|
{
|
[XLua.LuaCallCSharp]
|
public class DailyQuestModel : Model, IPlayerLoginOk, IBeforePlayerDataInitialize, IMapInitOk
|
{
|
const int DAILYQUEST_REDPOINTID = 78000;
|
const int EVERYDAY_REDPOINTID = 78001;
|
const int TIMELIMIT_REDPOINTID = 78002;
|
const int ACTIVEVALUE_REDPOINT = 78004;
|
const int REALMPOINT_REPOINT = 78005;
|
const int DAILYQUEST_REDPOINTIDBASE = 78100;
|
const int TRIALEXCHANGE_REDPOINTID = 78006;
|
|
Redpoint dailyQuestRedpoint = new Redpoint(DAILYQUEST_REDPOINTID);
|
public Redpoint everyDayRedpoint = new Redpoint(DAILYQUEST_REDPOINTID, EVERYDAY_REDPOINTID);
|
public Redpoint timeLimitRedpoint = new Redpoint(DAILYQUEST_REDPOINTID, TIMELIMIT_REDPOINTID);
|
Redpoint activeValueRedpoint = new Redpoint(EVERYDAY_REDPOINTID, ACTIVEVALUE_REDPOINT);
|
Redpoint realmPointRedpoint = new Redpoint(EVERYDAY_REDPOINTID, REALMPOINT_REPOINT);
|
|
int m_DailyQuestTotalActiveValue = 150;
|
public int dailyQuestTotalActiveValue {
|
get { return m_DailyQuestTotalActiveValue; }
|
}
|
|
int m_CurrentDailyQuest = 0;
|
public int currentDailyQuest {
|
get { return this.m_CurrentDailyQuest; }
|
set { this.m_CurrentDailyQuest = value; }
|
}
|
|
int m_CurrentRewardStageIndex = 0;
|
public int currentRewardStageIndex {
|
get { return m_CurrentRewardStageIndex; }
|
private set { m_CurrentRewardStageIndex = value; }
|
}
|
|
int m_CurrentActiveValue = 0;
|
public int currentActiveValue {
|
get { return m_CurrentActiveValue; }
|
private set {
|
if (m_CurrentActiveValue != value)
|
{
|
m_CurrentActiveValue = value;
|
|
if (currentActiveValueUpdateEvent != null)
|
{
|
currentActiveValueUpdateEvent();
|
}
|
}
|
}
|
}
|
|
Dictionary<int, DailyQuestData> dailyQuests = new Dictionary<int, DailyQuestData>();
|
Dictionary<int, int> dungeonToDailyQuestTable = new Dictionary<int, int>();
|
Dictionary<int, int> dailyActionToDailyQuestTable = new Dictionary<int, int>();
|
List<DailyQuestActiveValueReward> dailyQuestActiveValueRewards = new List<DailyQuestActiveValueReward>();
|
Dictionary<int, DailyQuestTimes> dailyQuestTimes = new Dictionary<int, DailyQuestTimes>();//除了副本的其他任务放在这里
|
Dictionary<int, DailyQuestOpenTime> dailyQuestOpenTimes = new Dictionary<int, DailyQuestOpenTime>();
|
Dictionary<int, Dictionary<int, List<int>>> questCalendar = new Dictionary<int, Dictionary<int, List<int>>>();
|
|
DungeonModel dungeonModel { get { return ModelCenter.Instance.GetModel<DungeonModel>(); } }
|
FairyLeagueModel fairyLeagueModel { get { return ModelCenter.Instance.GetModel<FairyLeagueModel>(); } }
|
FairyModel fairyModel { get { return ModelCenter.Instance.GetModel<FairyModel>(); } }
|
AllianceBossModel allianceBossModel { get { return ModelCenter.Instance.GetModel<AllianceBossModel>(); } }
|
public event Action<int> activeValueRewardGotEvent;
|
public event Action<int> dailyQuestProgressUpdateEvent;
|
public event Action currentActiveValueUpdateEvent;
|
|
public override void Init()
|
{
|
ParseConfig();
|
var values = DailyLivenessRewardConfig.GetValues();
|
for (int i = 0; i < values.Count; i++)
|
{
|
var config = values[i];
|
dailyQuestActiveValueRewards.Add(new DailyQuestActiveValueReward(config.id));
|
}
|
|
UpdateRedpoints();
|
|
fairyLeagueModel.onFairyLeagueBattleEvent += OnFairyLeagueBattle;
|
dungeonModel.dungeonRecordChangeEvent += OnDungeonRecordChange;
|
FuncOpen.Instance.OnFuncStateChangeEvent += OnFunctionStateChange;
|
PlayerDatas.Instance.playerDataRefreshEvent += OnPlayerDataRefresh;
|
fairyModel.guardSkyCompleteEvent += GuardSkyCompleteEvent;
|
PlayerDatas.Instance.fairyData.OnRefreshFairyInfo += OnRefreshFairyInfo;
|
PlayerDatas.Instance.fairyData.OnRefreshFairyMine += OnRefreshFairyInfo;
|
allianceBossModel.allianceBossStateRefresh += AllianceBossStateRefresh;
|
}
|
|
public override void UnInit()
|
{
|
fairyLeagueModel.onFairyLeagueBattleEvent -= OnFairyLeagueBattle;
|
dungeonModel.dungeonRecordChangeEvent -= OnDungeonRecordChange;
|
FuncOpen.Instance.OnFuncStateChangeEvent -= OnFunctionStateChange;
|
PlayerDatas.Instance.playerDataRefreshEvent -= OnPlayerDataRefresh;
|
fairyModel.guardSkyCompleteEvent -= GuardSkyCompleteEvent;
|
PlayerDatas.Instance.fairyData.OnRefreshFairyInfo -= OnRefreshFairyInfo;
|
PlayerDatas.Instance.fairyData.OnRefreshFairyMine -= OnRefreshFairyInfo;
|
allianceBossModel.allianceBossStateRefresh -= AllianceBossStateRefresh;
|
}
|
|
public void OnPlayerLoginOk()
|
{
|
DailyQuestActionTimer.Instance.Begin();
|
}
|
|
public void OnBeforePlayerDataInitialize()
|
{
|
currentActiveValue = 0;
|
}
|
|
public void OnMapInitOk()
|
{
|
UpdateRedpoints();
|
}
|
|
public List<int> GetDailyQuests()
|
{
|
return new List<int>(dailyQuests.Keys);
|
}
|
|
public List<int> GetDailyQuests(DailyQuestCategory _category)
|
{
|
var quests = new List<int>();
|
foreach (var key in dailyQuestOpenTimes.Keys)
|
{
|
var openTime = dailyQuestOpenTimes[key];
|
switch (_category)
|
{
|
case DailyQuestCategory.EveryDay:
|
if (openTime.always && ShouldShowOnDailyQuestWin(key))
|
{
|
quests.Add(key);
|
}
|
break;
|
case DailyQuestCategory.TimeLimit:
|
if (!openTime.always)
|
{
|
if ((DailyQuestType)key == DailyQuestType.CrossServerPk)
|
{
|
if (TimeUtility.OpenDay >= GeneralDefine.crossServerOneVsOneOpenDay
|
&& CrossServerOneVsOnePKSeason.Instance.InPkSeason(TimeUtility.ServerNow))
|
{
|
quests.Add(key);
|
}
|
}
|
else
|
{
|
quests.Add(key);
|
}
|
}
|
break;
|
}
|
}
|
|
switch (_category)
|
{
|
case DailyQuestCategory.EveryDay:
|
quests.Sort(EveryDayQuestCompare);
|
break;
|
case DailyQuestCategory.TimeLimit:
|
quests.Sort(TimeLimitQuestCompare);
|
break;
|
}
|
|
return quests;
|
}
|
|
public bool TryGetDailyQuest(int _id, out DailyQuestData _data)
|
{
|
return dailyQuests.TryGetValue(_id, out _data);
|
}
|
|
public bool TryGetActiveValueRewardData(int _id, out DailyQuestActiveValueReward _data)
|
{
|
for (int i = 0; i < dailyQuestActiveValueRewards.Count; i++)
|
{
|
if (dailyQuestActiveValueRewards[i].id == _id)
|
{
|
_data = dailyQuestActiveValueRewards[i];
|
return true;
|
}
|
}
|
|
_data = null;
|
return false;
|
}
|
|
public bool TryGetDailyQuestTimes(int _id, out DailyQuestTimes _dailyQuestTime)
|
{
|
_dailyQuestTime = default(DailyQuestTimes);
|
var config = DailyQuestConfig.Get(_id);
|
if (config != null && config.RelatedType == 1)
|
{
|
return dailyQuestTimes.TryGetValue(config.RelatedID, out _dailyQuestTime);
|
}
|
else
|
{
|
return false;
|
}
|
}
|
|
public bool IsDailyQuestUnLock(int _dailyQuestId)
|
{
|
var config = DailyQuestConfig.Get(_dailyQuestId);
|
var unlockFunctionId = config.UnLockFuncID;
|
var defaultUnlock = unlockFunctionId == 0 || FuncOpen.Instance.IsFuncOpen(unlockFunctionId);
|
|
switch ((DailyQuestType)_dailyQuestId)
|
{
|
case DailyQuestType.FairyFeast:
|
case DailyQuestType.FairyTask:
|
case DailyQuestType.FairyGrabBoss:
|
case DailyQuestType.AllianceBoss:
|
return defaultUnlock && PlayerDatas.Instance.baseData.FamilyId > 0;
|
case DailyQuestType.RuneTowerSweep:
|
return ModelCenter.Instance.GetModel<RuneTowerModel>().yesterdayPassFloor > 0;
|
case DailyQuestType.GuardSky:
|
return defaultUnlock && fairyModel.SatisfyGuardSkyFairyLv();
|
case DailyQuestType.FairyLeague:
|
return defaultUnlock && fairyModel.SatisfyOpenFairyLeagueLv();
|
default:
|
return defaultUnlock;
|
}
|
}
|
|
public int GetDailyQuestActiveValue(int _dailyQuestId)
|
{
|
var times = GetDailyQuestCompletedTimes(_dailyQuestId);
|
var config = DailyQuestConfig.Get(_dailyQuestId);
|
|
if (config.OnceActivityTime <= 0)
|
{
|
return 0;
|
}
|
else
|
{
|
return times / config.OnceActivityTime * config.OnceActivity;
|
}
|
}
|
|
public int GetDailyQuestTotalTimes(int _dailyQuestId)
|
{
|
var config = DailyQuestConfig.Get(_dailyQuestId);
|
switch (config.RelatedType)
|
{
|
case 1:
|
var dailyQuestOpenTime = DailyQuestOpenTimeConfig.Get(config.RelatedID);
|
if (dailyQuestOpenTime != null)
|
{
|
switch (config.RelatedID)
|
{
|
case 11:
|
return Math.Max(dailyQuestOpenTime.DayTimes, GetDailyQuestCompletedTimes(_dailyQuestId));
|
case 25:
|
if (dailyQuestTimes.ContainsKey(config.RelatedID))
|
{
|
return dailyQuestOpenTime.DayTimes + dailyQuestTimes[config.RelatedID].dayBuyTimes
|
+ dailyQuestTimes[config.RelatedID].dayUseItemTimes;
|
}
|
else
|
{
|
return dailyQuestOpenTime.DayTimes;
|
}
|
default:
|
return dailyQuestOpenTime.DayReKind > 0 ? dailyQuestOpenTime.DayTimes : dailyQuestOpenTime.WeekTimes;
|
}
|
}
|
else
|
{
|
return 0;
|
}
|
case 2:
|
return dungeonModel.GetTotalTimes(config.RelatedID);
|
}
|
|
return 0;
|
}
|
|
public int GetDailyQuestCompletedTimes(int _dailyQuestId)
|
{
|
var config = DailyQuestConfig.Get(_dailyQuestId);
|
switch (config.RelatedType)
|
{
|
case 1:
|
if (dailyQuestTimes.ContainsKey(config.RelatedID))
|
{
|
return dailyQuestTimes[config.RelatedID].completeTimes;
|
}
|
else
|
{
|
return 0;
|
}
|
case 2:
|
DungeonRecord dungeonRecord;
|
if (dungeonModel.TryGetRecord(config.RelatedID, out dungeonRecord))
|
{
|
return dungeonRecord.enterTimes;
|
}
|
else
|
{
|
return 0;
|
}
|
}
|
|
return 0;
|
}
|
|
public int GetDailyQuestCompletedNums(int relatedID)
|
{
|
if (dailyQuestTimes.ContainsKey(relatedID))
|
{
|
return dailyQuestTimes[relatedID].completeTimes;
|
}
|
else
|
{
|
return 0;
|
}
|
}
|
|
public int GetDungeonEnterNums(int relatedID)
|
{
|
DungeonRecord dungeonRecord;
|
if (dungeonModel.TryGetRecord(relatedID, out dungeonRecord))
|
{
|
return dungeonRecord.enterTimes;
|
}
|
else
|
{
|
return 0;
|
}
|
}
|
|
public int GetDailyQuestIdByDataMapId(int _dataMapId)
|
{
|
if (dungeonToDailyQuestTable.ContainsKey(_dataMapId))
|
{
|
return dungeonToDailyQuestTable[_dataMapId];
|
}
|
else
|
{
|
return 0;
|
}
|
}
|
|
public void OnDailyQuestCompletedTimesUpdate(HA315_tagMCDailyActionCnt _serverInfo)
|
{
|
for (int i = 0; i < _serverInfo.Count; i++)
|
{
|
var dailyAction = _serverInfo.ActionInfo[i];
|
if (dailyAction.DayFinishCnt > 0)
|
{
|
dailyQuestTimes[(int)dailyAction.ActionID] = new DailyQuestTimes()
|
{
|
completeTimes = dailyAction.DayFinishCnt,
|
dayBuyTimes = dailyAction.DayBuyTimes,
|
dayUseItemTimes = dailyAction.DayItemTimes,
|
};
|
}
|
else
|
{
|
dailyQuestTimes[(int)dailyAction.ActionID] = new DailyQuestTimes()
|
{
|
completeTimes = (int)dailyAction.WeekFinishCnt,
|
};
|
}
|
|
if (dailyActionToDailyQuestTable.ContainsKey((int)dailyAction.ActionID))
|
{
|
var dailyQuestId = dailyActionToDailyQuestTable[(int)dailyAction.ActionID];
|
UpdateDailyActionRedpoint(dailyQuestId);
|
}
|
|
if (dailyQuestProgressUpdateEvent != null)
|
{
|
dailyQuestProgressUpdateEvent((int)dailyAction.ActionID);
|
}
|
}
|
}
|
|
void OnDungeonRecordChange(int _dungeonId)
|
{
|
if (dungeonToDailyQuestTable.ContainsKey(_dungeonId))
|
{
|
var dailyQuestId = dungeonToDailyQuestTable[_dungeonId];
|
UpdateDailyActionRedpoint(dailyQuestId);
|
}
|
}
|
|
public void OnDailyQuestActiveValueInfoUpdate(HA333_tagMCDailyActivityInfoList _activeValueInfo)
|
{
|
currentActiveValue = (int)_activeValueInfo.CurValue;
|
|
currentRewardStageIndex = (int)_activeValueInfo.StageIndex;
|
|
for (int i = 0; i < dailyQuestActiveValueRewards.Count; i++)
|
{
|
var reward = dailyQuestActiveValueRewards[i];
|
var oldGot = reward.got;
|
dailyQuestActiveValueRewards[i].got = MathUtility.GetBitValue(_activeValueInfo.AwardRecord, (ushort)i);
|
|
if (oldGot != reward.got)
|
{
|
if (activeValueRewardGotEvent != null)
|
{
|
activeValueRewardGotEvent(reward.id);
|
}
|
}
|
}
|
|
UpdateActiveValueRedpoint();
|
}
|
|
public void RequestGetActiveValueReward(int _id)
|
{
|
var index = 0;
|
for (int i = 0; i < dailyQuestActiveValueRewards.Count; i++)
|
{
|
if (dailyQuestActiveValueRewards[i].id == _id)
|
{
|
index = i;
|
break;
|
}
|
}
|
|
var sendInfo = new CA504_tagCMPlayerGetReward();
|
sendInfo.RewardType = (int)GotServerRewardType.Def_RewardType_Activity;
|
sendInfo.DataEx = (uint)index;
|
sendInfo.DataExStrLen = 0;
|
sendInfo.DataExStr = string.Empty;
|
GameNetSystem.Instance.SendInfo(sendInfo);
|
}
|
|
public void RequestGetRealmPoint()
|
{
|
var sendInfo = new CA504_tagCMPlayerGetReward();
|
sendInfo.RewardType = (int)GotServerRewardType.Def_RewardType_DayRealmPoint;
|
sendInfo.DataExStrLen = 0;
|
sendInfo.DataExStr = string.Empty;
|
GameNetSystem.Instance.SendInfo(sendInfo);
|
}
|
|
public bool TryGetOpenTime(int _id, out DailyQuestOpenTime _openTime)
|
{
|
return dailyQuestOpenTimes.TryGetValue(_id, out _openTime);
|
}
|
|
public List<int> GetQuestByWeekTimeNode(int _week, int _timeNode)
|
{
|
var quests = new List<int>();
|
foreach (var item in dailyQuestOpenTimes.Values)
|
{
|
if (item.ContainTimeNode(_week, _timeNode))
|
{
|
quests.Add(item.id);
|
}
|
}
|
|
return quests;
|
}
|
|
/// <summary>
|
/// 时间 活动id列表
|
/// </summary>
|
/// <param name="_week"></param>
|
/// <returns></returns>
|
public Dictionary<int, List<int>> GetQuestByWeekTime(int _week)
|
{
|
var timeNodes = new Dictionary<int, List<int>>();
|
foreach (var item in GeneralDefine.dailyQuestOpenTime)
|
{
|
timeNodes[item] = GetQuestByWeekTimeNode(_week, item);
|
}
|
|
return timeNodes;
|
}
|
|
private void OnFunctionStateChange(int _functionId)
|
{
|
if (_functionId == 78)
|
{
|
UpdateRedpoints();
|
|
DailyQuestActionTimer.Instance.Begin();
|
}
|
}
|
|
private void GuardSkyCompleteEvent()
|
{
|
UpdateDailyActionRedpoint((int)DailyQuestType.GuardSky);
|
}
|
|
private void OnRefreshFairyInfo()
|
{
|
UpdateDailyActionRedpoint((int)DailyQuestType.GuardSky);
|
UpdateDailyActionRedpoint((int)DailyQuestType.FairyLeague);
|
}
|
|
private void AllianceBossStateRefresh()
|
{
|
UpdateDailyActionRedpoint((int)DailyQuestType.AllianceBoss);
|
}
|
|
private void OnPlayerDataRefresh(PlayerDataType _refreshType)
|
{
|
switch (_refreshType)
|
{
|
case PlayerDataType.LV:
|
if (PlayerDatas.Instance.baseData.LV == GeneralDefine.dailyQuestRedpointLevelLimit)
|
{
|
UpdateRedpoints();
|
}
|
break;
|
}
|
}
|
|
private void OnFairyLeagueBattle()
|
{
|
UpdateDailyActionRedpoint((int)DailyQuestType.FairyLeague);
|
}
|
|
public void UpdateRedpoints()
|
{
|
foreach (var dailyQuest in dailyQuests.Values)
|
{
|
UpdateDailyActionRedpoint(dailyQuest.id);
|
}
|
}
|
|
private void UpdateDailyActionRedpoint(int _questId)
|
{
|
if (!FuncOpen.Instance.IsFuncOpen(78))
|
{
|
return;
|
}
|
|
var dailyQuestState = GetQuestState(_questId);
|
var dailyQuest = dailyQuests[_questId];
|
|
if (dailyQuest.redpoint != null)
|
{
|
DailyQuestOpenTime openTime;
|
if (TryGetOpenTime(_questId, out openTime))
|
{
|
if (openTime.always)
|
{
|
switch ((DailyQuestType)_questId)
|
{
|
case DailyQuestType.FairyTask:
|
case DailyQuestType.BlastStove:
|
case DailyQuestType.Prayer:
|
case DailyQuestType.PersonalBoss:
|
case DailyQuestType.ElderGodArea:
|
case DailyQuestType.RuneTower:
|
case DailyQuestType.TreasureCollectSoul:
|
dailyQuest.redpoint.state = RedPointState.None;
|
break;
|
case DailyQuestType.DungeonAssist:
|
break;
|
default:
|
if (PlayerDatas.Instance.baseData.LV <= GeneralDefine.dailyQuestRedpointLevelLimit
|
&& (dailyQuestState == DailyQuestState.CanBuyTimes || dailyQuestState == DailyQuestState.Normal))
|
{
|
dailyQuest.redpoint.state = RedPointState.Simple;
|
}
|
else
|
{
|
dailyQuest.redpoint.state = RedPointState.None;
|
}
|
break;
|
}
|
}
|
else
|
{
|
var dailyQuestConfig = DailyQuestConfig.Get(_questId);
|
var dataMapId = dungeonModel.GetDataMapIdByMapId(PlayerDatas.Instance.baseData.MapID);
|
if (dailyQuestConfig.RelatedType == 2 && dataMapId == dailyQuestConfig.RelatedID)
|
{
|
dailyQuest.redpoint.state = RedPointState.None;
|
}
|
else
|
{
|
var completedTimes = GetDailyQuestCompletedTimes(dailyQuest.id);
|
var totalTimes = GetDailyQuestTotalTimes(dailyQuest.id);
|
switch ((DailyQuestType)_questId)
|
{
|
case DailyQuestType.HeavenBattle:
|
case DailyQuestType.FairyFeast:
|
if (dailyQuestState == DailyQuestState.CanBuyTimes || (dailyQuestState == DailyQuestState.Normal && completedTimes < totalTimes))
|
{
|
dailyQuest.redpoint.state = RedPointState.Simple;
|
}
|
else
|
{
|
dailyQuest.redpoint.state = RedPointState.None;
|
}
|
break;
|
case DailyQuestType.FairyLeague:
|
if (dailyQuestState == DailyQuestState.Normal)
|
{
|
var error = 0;
|
dailyQuest.redpoint.state = fairyLeagueModel.SatisfyEnterLeague(out error) ? RedPointState.Simple : RedPointState.None;
|
}
|
else
|
{
|
dailyQuest.redpoint.state = RedPointState.None;
|
}
|
break;
|
case DailyQuestType.FairyGrabBoss:
|
case DailyQuestType.AllianceBoss:
|
if (dailyQuestState == DailyQuestState.Normal)
|
{
|
dailyQuest.redpoint.state = completedTimes >= totalTimes ? RedPointState.None : RedPointState.Simple;
|
}
|
else
|
{
|
dailyQuest.redpoint.state = RedPointState.None;
|
}
|
break;
|
case DailyQuestType.CrossServerPk:
|
if (CrossServerOneVsOnePKSeason.Instance.isSatisfyMatch && FuncOpen.Instance.IsFuncOpen(157))
|
{
|
dailyQuest.redpoint.state = completedTimes >= totalTimes ? RedPointState.None : RedPointState.Simple;
|
}
|
else
|
{
|
dailyQuest.redpoint.state = RedPointState.None;
|
}
|
break;
|
default:
|
if (dailyQuestState == DailyQuestState.CanBuyTimes || dailyQuestState == DailyQuestState.Normal)
|
{
|
dailyQuest.redpoint.state = RedPointState.Simple;
|
}
|
else
|
{
|
dailyQuest.redpoint.state = RedPointState.None;
|
}
|
break;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
private void UpdateActiveValueRedpoint()
|
{
|
var count = dailyQuestActiveValueRewards.Count;
|
var anyAwardable = false;
|
for (int i = 0; i < count; i++)
|
{
|
var reward = dailyQuestActiveValueRewards[i];
|
if (!reward.got)
|
{
|
var config = DailyLivenessRewardConfig.Get(reward.id);
|
if (currentActiveValue >= config.Liveness)
|
{
|
anyAwardable = true;
|
break;
|
}
|
}
|
}
|
|
activeValueRedpoint.state = anyAwardable ? RedPointState.Simple : RedPointState.None;
|
}
|
|
private int EveryDayQuestCompare(int _lhs, int _rhs)
|
{
|
var state1 = GetQuestState(_lhs);
|
var state2 = GetQuestState(_rhs);
|
|
var config1 = DailyQuestConfig.Get(_lhs);
|
var config2 = DailyQuestConfig.Get(_rhs);
|
|
if (state1 == state2)
|
{
|
return config1.order < config2.order ? -1 : 1;
|
}
|
else
|
{
|
if (state1 == DailyQuestState.Completed)
|
{
|
return 1;
|
}
|
else if (state2 == DailyQuestState.Completed)
|
{
|
return -1;
|
}
|
else if (state1 == DailyQuestState.Locked)
|
{
|
return 1;
|
}
|
else if (state2 == DailyQuestState.Locked)
|
{
|
return -1;
|
}
|
else if (state1 == DailyQuestState.CanBuyTimes)
|
{
|
return 1;
|
}
|
else if (state2 == DailyQuestState.CanBuyTimes)
|
{
|
return -1;
|
}
|
else
|
{
|
return config1.order < config2.order ? -1 : 1;
|
}
|
}
|
|
}
|
|
private int TimeLimitQuestCompare(int _lhs, int _rhs)
|
{
|
var unLock1 = IsDailyQuestUnLock(_lhs);
|
var unLock2 = IsDailyQuestUnLock(_rhs);
|
|
if (unLock1 && !unLock2)
|
{
|
return -1;
|
}
|
else if (!unLock1 && unLock2)
|
{
|
return 1;
|
}
|
else
|
{
|
DailyQuestOpenTime openTime1;
|
TryGetOpenTime(_lhs, out openTime1);
|
|
DailyQuestOpenTime openTime2;
|
TryGetOpenTime(_rhs, out openTime2);
|
|
var dayOfWeek = (int)TimeUtility.ServerNow.DayOfWeek;
|
var isActiveDay1 = openTime1.always || openTime1.GetHourMinuteByWeek(dayOfWeek) != null;
|
var isActiveDay2 = openTime2.always || openTime2.GetHourMinuteByWeek(dayOfWeek) != null;
|
|
if (isActiveDay1 && !isActiveDay2)
|
{
|
return -1;
|
}
|
else if (!isActiveDay1 && isActiveDay2)
|
{
|
return 1;
|
}
|
else
|
{
|
var inOpenTime1 = openTime1.InOpenTime();
|
var inOpenTime2 = openTime2.InOpenTime();
|
|
if (inOpenTime1 && !inOpenTime2)
|
{
|
return -1;
|
}
|
else if (!inOpenTime1 && inOpenTime2)
|
{
|
return 1;
|
}
|
else if (!inOpenTime1 && !inOpenTime2)
|
{
|
var serverHour = TimeUtility.ServerNow.Hour;
|
var serverMinute = TimeUtility.ServerNow.Minute;
|
|
HourMinute hourMinute1;
|
var miss1 = openTime1.TryGetTodayNearestOpenTime(out hourMinute1) && hourMinute1.AfterOpenTime(serverHour, serverMinute);
|
HourMinute hourMinute2;
|
var miss2 = openTime2.TryGetTodayNearestOpenTime(out hourMinute2) && hourMinute2.AfterOpenTime(serverHour, serverMinute);
|
|
if (!miss1 && miss2)
|
{
|
return -1;
|
}
|
else if (miss1 && !miss2)
|
{
|
return 1;
|
}
|
else
|
{
|
return HourMinute.Compare(hourMinute1, hourMinute2);
|
}
|
}
|
else
|
{
|
return _lhs < _rhs ? -1 : 1;
|
}
|
}
|
}
|
|
}
|
|
private bool ShouldShowOnDailyQuestWin(int _dailyQuestId)
|
{
|
switch ((DailyQuestType)_dailyQuestId)
|
{
|
case DailyQuestType.BossHome:
|
var bossHomeModel = ModelCenter.Instance.GetModel<BossHomeModel>();
|
var vipLevel = PlayerDatas.Instance.baseData.VIPLv;
|
return vipLevel >= bossHomeModel.GetFloorVipRequirement(1);
|
case DailyQuestType.PersonalBoss:
|
return ModelCenter.Instance.GetModel<DungeonModel>().GetTotalTimes(PersonalBossModel.PERSONALBOSS_MAPID) > 0;
|
default:
|
return true;
|
}
|
}
|
|
public DailyQuestState GetQuestState(int _dailyQuestId)
|
{
|
var isUnLocked = IsDailyQuestUnLock(_dailyQuestId);
|
if (!isUnLocked)
|
{
|
return DailyQuestState.Locked;
|
}
|
|
DailyQuestOpenTime openTime;
|
if (TryGetOpenTime(_dailyQuestId, out openTime))
|
{
|
var inOpenTime = openTime.InOpenTime();
|
if (!inOpenTime)
|
{
|
return DailyQuestState.OutTime;
|
}
|
}
|
|
switch ((DailyQuestType)_dailyQuestId)
|
{
|
case DailyQuestType.HeavenBattle:
|
case DailyQuestType.FairyFeast:
|
case DailyQuestType.FairyLeague:
|
case DailyQuestType.FairyGrabBoss:
|
case DailyQuestType.AncientBattleGround:
|
return DailyQuestState.Normal;
|
case DailyQuestType.GuardSky:
|
if (!fairyModel.completeGuardSky)
|
{
|
return DailyQuestState.Normal;
|
}
|
break;
|
case DailyQuestType.AllianceBoss:
|
if (allianceBossModel.isActivityOver)
|
{
|
return DailyQuestState.Completed;
|
}
|
return DailyQuestState.Normal;
|
}
|
|
var completedTimes = GetDailyQuestCompletedTimes(_dailyQuestId);
|
var totalTimes = GetDailyQuestTotalTimes(_dailyQuestId);
|
|
var config = DailyQuestConfig.Get(_dailyQuestId);
|
if (completedTimes >= totalTimes)
|
{
|
switch (config.RelatedType)
|
{
|
case 1:
|
switch (config.RelatedID)
|
{
|
case 11:
|
{
|
var dailyQuestOpenTime = DailyQuestOpenTimeConfig.Get(config.RelatedID);
|
if (completedTimes >= dailyQuestOpenTime.DayTimes + GeneralDefine.runeTowerSweepBuyTimes)
|
{
|
return DailyQuestState.Completed;
|
}
|
else
|
{
|
return DailyQuestState.CanBuyTimes;
|
}
|
}
|
case 19:
|
return DailyQuestState.Normal;
|
case 25:
|
{
|
var dailyQuestOpenTime = DailyQuestOpenTimeConfig.Get(config.RelatedID);
|
if (completedTimes >= dailyQuestOpenTime.DayTimes +
|
dailyQuestOpenTime.DayBuyTimes + dailyQuestOpenTime.DayItemAddTimes)
|
{
|
return DailyQuestState.Completed;
|
}
|
else
|
{
|
return DailyQuestState.CanBuyTimes;
|
}
|
}
|
default:
|
return DailyQuestState.Completed;
|
}
|
case 2:
|
DungeonRecord record;
|
dungeonModel.TryGetRecord(config.RelatedID, out record);
|
var buyTimes = record != null ? record.buyTimes : 0;
|
var buyTimesLimit = dungeonModel.GetBuyTimesLimit(config.RelatedID);
|
return buyTimes >= buyTimesLimit ? DailyQuestState.Completed : DailyQuestState.CanBuyTimes;
|
}
|
}
|
|
return DailyQuestState.Normal;
|
}
|
|
public static string GetDailyQuestUnLockDescription(int _dailyQuestId)
|
{
|
var type = (DailyQuestType)_dailyQuestId;
|
var dailyConfig = DailyQuestConfig.Get(_dailyQuestId);
|
if (type == DailyQuestType.FairyFeast || type == DailyQuestType.FairyTask || type == DailyQuestType.FairyGrabBoss)
|
{
|
if (PlayerDatas.Instance.fairyData.HasFairy)
|
{
|
return StringUtility.Contact(FuncOpen.Instance.GetLimitLv(dailyConfig.UnLockFuncID), Language.Get("Z1041"));
|
}
|
else
|
{
|
return Language.Get("DailyQuestWin_Participate");
|
}
|
}
|
|
var _fairyModel = ModelCenter.Instance.GetModel<FairyModel>();
|
switch (type)
|
{
|
case DailyQuestType.AllianceBoss:
|
if (!PlayerDatas.Instance.fairyData.HasFairy)
|
{
|
return Language.Get("DailyQuestWin_Participate");
|
}
|
break;
|
case DailyQuestType.GuardSky:
|
if (!PlayerDatas.Instance.fairyData.HasFairy)
|
{
|
return Language.Get("DailyQuestWin_Participate");
|
}
|
if (!_fairyModel.SatisfyGuardSkyFairyLv())
|
{
|
return Language.Get("DailyquestXMLevel", _fairyModel.guardSkyOpenFairyLv);
|
}
|
break;
|
case DailyQuestType.FairyLeague:
|
if (!PlayerDatas.Instance.fairyData.HasFairy)
|
{
|
return Language.Get("DailyQuestWin_Participate");
|
}
|
if (!_fairyModel.SatisfyOpenFairyLeagueLv())
|
{
|
return Language.Get("DailyquestXMLevel", _fairyModel.fairyLeagueLimit);
|
}
|
break;
|
}
|
|
var description = string.Empty;
|
var treasureModel = ModelCenter.Instance.GetModel<TreasureModel>();
|
var functionConfig = FuncOpenLVConfig.Get(dailyConfig.UnLockFuncID);
|
|
if (functionConfig == null)
|
{
|
description = Language.Get("DailyQuest_NoLevelLimit");
|
}
|
else if (functionConfig.LimitMagicWeapon > 0)
|
{
|
Treasure treasure = null;
|
if (treasureModel.TryGetTreasure(functionConfig.LimitMagicWeapon / 100, out treasure))
|
{
|
var treasureConfig = TreasureConfig.Get(functionConfig.LimitMagicWeapon / 100);
|
description = Language.Get("DailyQuestwin1", treasureConfig.Name);
|
}
|
}
|
else if (functionConfig.LimitLV > 0 && functionConfig.LimitMissionID > 0)
|
{
|
var config = PyTaskConfig.Get(functionConfig.LimitMissionID);
|
var taskInfoConfig = TASKINFOConfig.Get(config.name);
|
description = Language.Get("DailyQuestwin2", functionConfig.LimitLV);
|
}
|
else if (functionConfig.LimitMissionID > 0)
|
{
|
var config = PyTaskConfig.Get(functionConfig.LimitMissionID);
|
var taskInfoConfig = TASKINFOConfig.Get(config.name);
|
description = Language.Get("DailyQuestwin8");
|
}
|
else
|
{
|
description = StringUtility.Contact(functionConfig.LimitLV, Language.Get("Z1041"));
|
}
|
|
if (type == DailyQuestType.RuneTowerSweep && FuncOpen.Instance.IsFuncOpen(80))
|
{
|
var runeTowerModel = ModelCenter.Instance.GetModel<RuneTowerModel>();
|
if (runeTowerModel.yesterdayPassFloor <= 0)
|
{
|
var runeModel = ModelCenter.Instance.GetModel<RuneModel>();
|
if (runeModel.passRuneTowerFloor > 0)
|
{
|
description = Language.Get("DailyQuestwin4");
|
}
|
else
|
{
|
description = Language.Get("DailyQuestwin3");
|
}
|
}
|
}
|
|
return description;
|
}
|
|
private void ParseConfig()
|
{
|
var allConfigs = DailyQuestConfig.GetValues();
|
|
var redpointIndex = 1;
|
foreach (var config in allConfigs)
|
{
|
if (VersionConfig.Get().isBanShu && config.ID == 12)
|
{
|
continue;
|
}
|
|
var openTime = default(DailyQuestOpenTime);
|
var redpointParent = 0;
|
switch (config.RelatedType)
|
{
|
case 1:
|
var activityOpenTime = DailyQuestOpenTimeConfig.Get(config.RelatedID);
|
openTime = dailyQuestOpenTimes[config.ID] = new DailyQuestOpenTime(config.ID);
|
openTime.ParseQuestNormalOpenTime(activityOpenTime.OpenTime, activityOpenTime.Duration);
|
openTime.ParseQuestSpecialOpenTimes(DailyQuestSpecialOpenTimeConfig.GetDailyQuestTimes(config.RelatedID));
|
openTime.ParseQuestMixServerOpenTime(DailyQuestMixServerStateTimeConfig.GetDailyQuestTimes(config.RelatedID));
|
dailyActionToDailyQuestTable[config.RelatedID] = config.ID;
|
break;
|
case 2:
|
var dungeonOpenTimes = DungeonStateTimeConfig.DungeonStateCanEnterFB(config.RelatedID);
|
openTime = dailyQuestOpenTimes[config.ID] = new DailyQuestOpenTime(config.ID);
|
openTime.ParseDungeonNormalOpenTimes(dungeonOpenTimes);
|
openTime.ParseDungeonSpecialOpenTimes(DungeonSpecialStateTimeConfig.GetDungeonTimes(config.RelatedID));
|
openTime.ParseDungeonMixServerOpenTimes(DungeonMixServerStateTimeConfig.GetDungeonTimes(config.RelatedID));
|
dungeonToDailyQuestTable[config.RelatedID] = config.ID;
|
break;
|
}
|
|
redpointParent = openTime.always ? EVERYDAY_REDPOINTID : TIMELIMIT_REDPOINTID;
|
dailyQuests[config.ID] = new DailyQuestData(config.ID, DAILYQUEST_REDPOINTIDBASE + redpointIndex++, redpointParent);
|
}
|
|
}
|
|
public enum DailyQuestCategory
|
{
|
EveryDay = 1,
|
TimeLimit = 2,
|
}
|
|
public enum DailyQuestState
|
{
|
Locked = 0,
|
OutTime = 2,
|
Normal = 3,
|
CanBuyTimes = 5,
|
Completed = 6,
|
}
|
}
|
|
}
|
|
|
|
