//--------------------------------------------------------
|
// [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 DAILYQUEST_REDPOINTIDBASE = 78100;
|
const int TRIALEXCHANGE_REDPOINTID = 78006;
|
const int LIVENESSREWARD_REDPOINTID = 78007;
|
|
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);
|
public Redpoint LivenessRewardRedPoint = new Redpoint(EVERYDAY_REDPOINTID, LIVENESSREWARD_REDPOINTID);
|
|
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_WannaLookDailyQuest = 0;
|
public int wannaLookDailyQuest {
|
get { return this.m_WannaLookDailyQuest; }
|
set { this.m_WannaLookDailyQuest = 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();
|
}
|
}
|
}
|
}
|
|
int m_UsableActivePoint = 0;
|
public int usableActivePoint {
|
get { return m_UsableActivePoint; }
|
private set {
|
if (m_UsableActivePoint != value)
|
{
|
m_UsableActivePoint = value;
|
|
if (usableActivePointUpdateEvent != null)
|
{
|
usableActivePointUpdateEvent();
|
}
|
}
|
}
|
}
|
|
|
DailyQuestCategory m_Category;
|
public DailyQuestCategory category {
|
get {
|
return m_Category;
|
}
|
set {
|
if (m_Category != value)
|
{
|
m_Category = value;
|
if (categoryChangeEvent != null)
|
{
|
categoryChangeEvent();
|
}
|
}
|
}
|
}
|
|
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>>>();
|
List<int> DailyQuestLVList = new 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>(); } }
|
TaskModel taskModel { get { return ModelCenter.Instance.GetModel<TaskModel>(); } }
|
MapModel mapModel { get { return ModelCenter.Instance.GetModel<MapModel>(); } }
|
SkyTowerModel skyTowerModel { get { return ModelCenter.Instance.GetModel<SkyTowerModel>(); } }
|
HazyRegionModel hazyRegionModel { get { return ModelCenter.Instance.GetModel<HazyRegionModel>(); } }
|
|
public event Action<int> activeValueRewardGotEvent;
|
public event Action<int> dailyQuestProgressUpdateEvent;
|
public event Action currentActiveValueUpdateEvent;
|
public event Action usableActivePointUpdateEvent;
|
public event Action categoryChangeEvent;
|
|
|
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));
|
}
|
|
dailyQuestActiveValueRewards.Sort((x, y) => { return x.id.CompareTo(y.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;
|
usableActivePoint = 0;
|
}
|
|
public void OnMapInitOk()
|
{
|
UpdateRedpoints();
|
}
|
|
public List<int> GetDailyQuests()
|
{
|
var quests = new List<int>(dailyQuests.Keys);
|
if (quests.Contains((int)DailyQuestType.SkyTower) && skyTowerModel.allPassed)
|
{
|
quests.Remove((int)DailyQuestType.SkyTower);
|
}
|
|
return quests;
|
}
|
|
public List<LivenessRewardData> GetLivenessRewardDatas()
|
{
|
List<LivenessRewardData> DataList = new List<LivenessRewardData>();
|
List<LivenessRewardData>[] DataListAry = new List<LivenessRewardData>[3]
|
{
|
new List<LivenessRewardData>(),//可领取
|
new List<LivenessRewardData>(),//未达成条件
|
new List<LivenessRewardData>() //已领取
|
};
|
for (int i = 0; i < dailyQuestActiveValueRewards.Count; i++)
|
{
|
var Reward = dailyQuestActiveValueRewards[i];
|
LivenessRewardData Data = new LivenessRewardData();
|
Data.config = DailyLivenessRewardConfig.Get(Reward.id);
|
if (Data.config.Liveness > currentActiveValue)
|
{
|
Data.state = 0;
|
DataListAry[1].Add(Data);
|
}
|
else
|
{
|
if (Reward.got)
|
{
|
Data.state = 2;
|
DataListAry[2].Add(Data);
|
}
|
else
|
{
|
Data.state = 1;
|
DataListAry[0].Add(Data);
|
}
|
|
}
|
}
|
foreach (var TempDataList in DataListAry)
|
{
|
foreach (var TempData in TempDataList)
|
{
|
DataList.Add(TempData);
|
}
|
}
|
return DataList;
|
}
|
|
|
|
public List<int> GetDailyQuests(DailyQuestCategory category, bool LimitLv = false)
|
{
|
var quests = new List<int>();
|
var PlayerLV = PlayerDatas.Instance.baseData.LV;
|
var NextLV = 0;
|
if (PlayerLV >= DailyQuestLVList[DailyQuestLVList.Count - 1])
|
{
|
NextLV = PlayerLV;
|
}
|
else
|
{
|
for (int i = 0; i < DailyQuestLVList.Count; i++)
|
{
|
if (DailyQuestLVList[i] > PlayerLV)
|
{
|
NextLV = DailyQuestLVList[i];
|
break;
|
}
|
}
|
}
|
foreach (var key in dailyQuestOpenTimes.Keys)
|
{
|
if (key == (int)DailyQuestType.SkyTower && skyTowerModel.allPassed)
|
{
|
continue;
|
}
|
|
var openTime = dailyQuestOpenTimes[key];
|
switch (category)
|
{
|
case DailyQuestCategory.EveryDay:
|
if (openTime.always && ShouldShowOnDailyQuestWin(key))
|
{
|
if (LimitLv)
|
{
|
if (GetDailyQuestLV(key) <= NextLV)
|
{
|
quests.Add(key);
|
}
|
}
|
else
|
{
|
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));
|
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);
|
}
|
}
|
|
private bool IsGetNewLivenessReward(int OldValue, int NewValue)
|
{
|
foreach (var reward in dailyQuestActiveValueRewards)
|
{
|
if (reward.got)
|
{
|
continue;
|
}
|
var RewardConfig = DailyLivenessRewardConfig.Get(reward.id);
|
if (OldValue < RewardConfig.Liveness && NewValue >= RewardConfig.Liveness)
|
{
|
return true;
|
}
|
}
|
return false;
|
}
|
|
public void OnDailyQuestActiveValueInfoUpdate(HA333_tagMCDailyActivityInfoList _activeValueInfo)
|
{
|
|
int OldCurrentActiveValue = currentActiveValue;
|
currentActiveValue = (int)_activeValueInfo.CurValue;
|
currentRewardStageIndex = (int)_activeValueInfo.StageIndex;
|
|
usableActivePoint = (int)_activeValueInfo.UsableActivePoint;
|
|
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);
|
}
|
}
|
}
|
if (IsGetNewLivenessReward(OldCurrentActiveValue, currentActiveValue))
|
{
|
LivenessRewardRedPoint.state = RedPointState.Simple;
|
}
|
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 UpdateHazyRegion()
|
{
|
UpdateDailyActionRedpoint((int)DailyQuestType.HazyRegion);
|
}
|
|
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;
|
case DailyQuestType.HazyRegion:
|
dailyQuest.redpoint.state = hazyRegionModel.redpoint.state == RedPointState.Simple ?
|
RedPointState.Simple : RedPointState.None;
|
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:
|
case 25:
|
return DailyQuestState.Normal;
|
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)
|
{
|
var config = FuncOpenLVConfig.Get(dailyConfig.UnLockFuncID);
|
if (config.LimitMissionID > 0)
|
{
|
var taskConfig = PyTaskConfig.Get(config.LimitMissionID);
|
return Language.Get("DailyQuestwin2", taskConfig.lv);
|
}
|
else
|
{
|
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;
|
}
|
|
public void GotoDailyQuest(int _id)
|
{
|
switch ((DailyQuestType)_id)
|
{
|
case DailyQuestType.FairyLand:
|
GotoNormalDungeon(_id);
|
break;
|
case DailyQuestType.IceCrystal:
|
WindowCenter.Instance.Open<IceCrystalVeinWin>();
|
break;
|
case DailyQuestType.GuardSky:
|
var _fairyModel = ModelCenter.Instance.GetModel<FairyModel>();
|
if (!_fairyModel.SatisfyGuardSkyFairyLv())
|
{
|
SysNotifyMgr.Instance.ShowTip("GuardSkyOpenLvError", _fairyModel.guardSkyOpenFairyLv);
|
break;
|
}
|
if (_fairyModel.completeGuardSky)
|
{
|
SysNotifyMgr.Instance.ShowTip("TheEmperor1");
|
break;
|
}
|
GotoNormalDungeon(_id);
|
break;
|
case DailyQuestType.Kirin:
|
GotoMultipleDifficultyDungeon(_id);
|
break;
|
case DailyQuestType.BountyMission:
|
WindowJumpMgr.Instance.WindowJumpTo(JumpUIType.BountyInterface);
|
break;
|
case DailyQuestType.Demon:
|
GotoChaosDemon(_id);
|
break;
|
case DailyQuestType.Trial:
|
GotoTrial();
|
break;
|
case DailyQuestType.BlastStove:
|
GotoBlastStove();
|
break;
|
case DailyQuestType.AncientBattleGround:
|
GotoNormalDungeon(_id, dungeonModel.GetBelongToLine(_id));
|
break;
|
case DailyQuestType.EmperorRelic:
|
GotoNuwa();
|
break;
|
case DailyQuestType.WyTaiChi:
|
GotoTaiChiDungeon(_id);
|
break;
|
case DailyQuestType.HeavenBattle:
|
GotoHeavenBattleDungeon(_id);
|
break;
|
case DailyQuestType.Prayer:
|
WindowCenter.Instance.Close<DailyQuestWin>();
|
WindowCenter.Instance.Open<WelfareWin>(false, 1);
|
WindowCenter.Instance.Close<MainInterfaceWin>();
|
break;
|
case DailyQuestType.WorldBoss:
|
WindowCenter.Instance.Close<DailyQuestWin>();
|
WindowCenter.Instance.Open<FindPreciousFrameWin>(false, 1);
|
break;
|
case DailyQuestType.DemonJar:
|
WindowCenter.Instance.Close<DailyQuestWin>();
|
WindowCenter.Instance.Open<FindPreciousFrameWin>(false, 0);
|
break;
|
case DailyQuestType.FairyTask:
|
WindowJumpMgr.Instance.WindowJumpTo(JumpUIType.UnionTask);
|
break;
|
case DailyQuestType.FairyLeague:
|
WindowCenter.Instance.Close<DailyQuestWin>();
|
WindowCenter.Instance.Open<UnionPanel>(false, 4);
|
break;
|
case DailyQuestType.FairyFeast:
|
if (CrossServerUtility.IsCrossServer())
|
{
|
SysNotifyMgr.Instance.ShowTip("CrossMap10");
|
break;
|
}
|
var config = DailyQuestConfig.Get(_id);
|
dungeonModel.SingleChallenge(config.RelatedID);
|
break;
|
case DailyQuestType.RuneTowerSweep:
|
RuneTowerWin.guideSweep = true;
|
WindowCenter.Instance.Close<DailyQuestWin>();
|
WindowCenter.Instance.Open<TowerWin>(false, 1);
|
break;
|
case DailyQuestType.BossHome:
|
WindowCenter.Instance.Close<DailyQuestWin>();
|
WindowCenter.Instance.Open<FindPreciousFrameWin>(false, 2);
|
break;
|
case DailyQuestType.PersonalBoss:
|
WindowCenter.Instance.Close<DailyQuestWin>();
|
WindowCenter.Instance.Open<FindPreciousFrameWin>(false, 3);
|
break;
|
case DailyQuestType.ElderGodArea:
|
WindowCenter.Instance.Close<DailyQuestWin>();
|
WindowCenter.Instance.Open<FindPreciousFrameWin>(false, 4);
|
break;
|
case DailyQuestType.RuneTower:
|
WindowCenter.Instance.Close<DailyQuestWin>();
|
WindowCenter.Instance.Open<TowerWin>(false, 1);
|
break;
|
case DailyQuestType.TreasureCollectSoul:
|
GotoTreasureCollectSoul();
|
break;
|
case DailyQuestType.DungeonAssist:
|
WindowCenter.Instance.Open<DungeonAssistWin>();
|
break;
|
case DailyQuestType.FairyGrabBoss:
|
WindowCenter.Instance.Close<DailyQuestWin>();
|
WindowCenter.Instance.Open<LootPreciousFrameWin>(false, 1);
|
break;
|
case DailyQuestType.KillMonster:
|
var point = mapModel.GetRecommendHangPoint();
|
var mapEventConfig = MapEventPointConfig.Get(point);
|
mapModel.wannaLookLocalMap = mapEventConfig.DataMapID;
|
WindowCenter.Instance.Close<DailyQuestWin>();
|
WindowCenter.Instance.Open<LocalMapWin>();
|
break;
|
case DailyQuestType.GatherSoulDungeon:
|
GotoNormalDungeon(_id, 0);
|
break;
|
case DailyQuestType.CrossServerPk:
|
WindowCenter.Instance.Close<DailyQuestWin>();
|
WindowCenter.Instance.Open<CrossServerWin>(false, 0);
|
break;
|
case DailyQuestType.AllianceBoss:
|
GotoAllianceBoss(_id, 0);
|
break;
|
case DailyQuestType.RidingPetActivity:
|
WindowCenter.Instance.Close<DailyQuestWin>();
|
WindowCenter.Instance.Open<LootPreciousFrameWin>(false, 1);
|
break;
|
case DailyQuestType.HazyRegion:
|
WindowCenter.Instance.Close<DailyQuestWin>();
|
WindowCenter.Instance.Open<HazyRegionFrameWin>();
|
break;
|
case DailyQuestType.SkyTower:
|
GotoSkyTower();
|
break;
|
default:
|
CSharpCallLua.GotoLuaDailyQuest(_id);
|
break;
|
}
|
|
WindowJumpMgr.Instance.ClearJumpData();
|
}
|
|
private void GotoTaiChiDungeon(int _dailyQuestId, int _lineId = 0)
|
{
|
if (VersionConfig.Get().isBanShu)
|
{
|
return;
|
}
|
|
var config = DailyQuestConfig.Get(_dailyQuestId);
|
currentDailyQuest = config.ID;
|
dungeonModel.currentDungeon = new Dungeon(config.RelatedID, _lineId);
|
WindowCenter.Instance.Open<TaiChilDungeonEntranceWin>();
|
}
|
|
private void GotoHeavenBattleDungeon(int _dailyQuestId, int _lineId = 0)
|
{
|
var config = DailyQuestConfig.Get(_dailyQuestId);
|
dungeonModel.currentDungeon = new Dungeon(config.RelatedID, _lineId);
|
WindowCenter.Instance.Open<HeavenBattleWin>();
|
}
|
|
private void GotoNormalDungeon(int _dailyQuestId, int _lineId = 0)
|
{
|
var config = DailyQuestConfig.Get(_dailyQuestId);
|
dungeonModel.currentDungeon = new Dungeon(config.RelatedID, _lineId);
|
WindowCenter.Instance.Open<NormalDungeonEntranceWin>();
|
}
|
|
private void GotoMultipleDifficultyDungeon(int _dailyQuestId)
|
{
|
var config = DailyQuestConfig.Get(_dailyQuestId);
|
dungeonModel.currentDungeon = new Dungeon(config.RelatedID, 0);
|
dungeonModel.selectedKylinDungeon = default(Dungeon);
|
WindowCenter.Instance.Open<MultipleDifficultyDungeonWin>();
|
}
|
|
private void GotoChaosDemon(int _dailyQuestId)
|
{
|
var completedTimes = GetDailyQuestCompletedTimes(_dailyQuestId);
|
var totalTimes = GetDailyQuestTotalTimes(_dailyQuestId);
|
if (completedTimes >= totalTimes)
|
{
|
if (DayRemind.Instance.GetDayRemind(DayRemind.DUNGEON_DEMON_TIP))
|
{
|
GotoNormalDungeon(_dailyQuestId);
|
}
|
else
|
{
|
ConfirmCancel.ToggleConfirmCancel(Language.Get("Mail101"), Language.Get("TodayDungeonComplete"), Language.Get("TodayNoNotify"), (bool isOk, bool isToggle) =>
|
{
|
if (isOk)
|
{
|
GotoNormalDungeon(_dailyQuestId);
|
}
|
if (isToggle)
|
{
|
DayRemind.Instance.SetDayRemind(DayRemind.DUNGEON_DEMON_TIP, true);
|
}
|
});
|
}
|
return;
|
}
|
|
GotoNormalDungeon(_dailyQuestId);
|
}
|
|
private void GotoNuwa()
|
{
|
var id = (int)DailyQuestType.EmperorRelic;
|
var completedTimes = GetDailyQuestCompletedTimes(id);
|
var totalTimes = GetDailyQuestTotalTimes(id);
|
if (completedTimes >= totalTimes)
|
{
|
if (DayRemind.Instance.GetDayRemind(DayRemind.DUNGEON_RELIC_TIP))
|
{
|
GotoNormalDungeon(id);
|
}
|
else
|
{
|
ConfirmCancel.ToggleConfirmCancel(Language.Get("Mail101"), Language.Get("TodayDungeonComplete"), Language.Get("TodayNoNotify"), (bool isOk, bool isToggle) =>
|
{
|
if (isOk)
|
{
|
GotoNormalDungeon(id);
|
}
|
if (isToggle)
|
{
|
DayRemind.Instance.SetDayRemind(DayRemind.DUNGEON_RELIC_TIP, true);
|
}
|
});
|
}
|
return;
|
}
|
GotoNormalDungeon(id);
|
}
|
|
private void GotoTrial()
|
{
|
var id = (int)DailyQuestType.Trial;
|
var config = DailyQuestConfig.Get(id);
|
|
var completedTimes = GetDailyQuestCompletedTimes(id);
|
var totalTimes = GetDailyQuestTotalTimes(id);
|
|
if (completedTimes >= totalTimes)
|
{
|
if (DayRemind.Instance.GetDayRemind(DayRemind.DUNGEON_TRIAL_TIP))
|
{
|
dungeonModel.currentDungeon = new Dungeon(config.RelatedID, 0);
|
WindowCenter.Instance.Open<TrialDungeonSelectWin>();
|
}
|
else
|
{
|
ConfirmCancel.ToggleConfirmCancel(Language.Get("Mail101"), Language.Get("TodayTrialComplete"), Language.Get("TodayNoNotify"), (bool isOk, bool isToggle) =>
|
{
|
if (isOk)
|
{
|
dungeonModel.currentDungeon = new Dungeon(config.RelatedID, 0);
|
WindowCenter.Instance.Open<TrialDungeonSelectWin>();
|
}
|
if (isToggle)
|
{
|
DayRemind.Instance.SetDayRemind(DayRemind.DUNGEON_TRIAL_TIP, true);
|
}
|
});
|
}
|
return;
|
}
|
|
dungeonModel.currentDungeon = new Dungeon(config.RelatedID, 0);
|
WindowCenter.Instance.Open<TrialDungeonSelectWin>();
|
}
|
|
private void GotoBlastStove()
|
{
|
WindowCenter.Instance.Close<DailyQuestWin>();
|
WindowCenter.Instance.Open<AlchemyBaseWin>();
|
}
|
|
private void GotoBountyMission()
|
{
|
var inDungeon = MapUtility.IsDungeon(PlayerDatas.Instance.baseData.MapID);
|
if (inDungeon)
|
{
|
SysNotifyMgr.Instance.ShowTip("InDungeon_CantGo");
|
}
|
else
|
{
|
taskModel.DailyBountyMove();
|
WindowCenter.Instance.Close<DailyQuestWin>();
|
WindowCenter.Instance.Open<MainInterfaceWin>();
|
}
|
}
|
|
private void GotoAllianceBoss(int id, int lineId)
|
{
|
WindowCenter.Instance.Open<LootPreciousFrameWin>(false, 3);
|
}
|
|
private void GotoTreasureCollectSoul()
|
{
|
var treasureModel = ModelCenter.Instance.GetModel<TreasureModel>();
|
var treasures = treasureModel.GetTreasureCategory(TreasureCategory.Human);
|
var gotoTreasureId = 0;
|
for (int i = treasures.Count - 1; i >= 0; i--)
|
{
|
if (IsTreasureCollectSoul(treasures[i]))
|
{
|
gotoTreasureId = treasures[i];
|
break;
|
}
|
}
|
|
if (gotoTreasureId == 0)
|
{
|
for (int i = 0; i < treasures.Count; i++)
|
{
|
Treasure treasure;
|
if (treasureModel.TryGetTreasure(treasures[i], out treasure))
|
{
|
if (treasure != null
|
&& (treasure.state == TreasureState.Locked || treasure.state == TreasureState.Collecting))
|
{
|
gotoTreasureId = treasure.id;
|
break;
|
}
|
}
|
}
|
}
|
|
WindowCenter.Instance.Close<DailyQuestWin>();
|
|
if (gotoTreasureId == 0)
|
{
|
treasureModel.currentCategory = TreasureCategory.Human;
|
WindowJumpMgr.Instance.WindowJumpTo(JumpUIType.TreasureFunc1);
|
}
|
else
|
{
|
var config = TreasureConfig.Get(gotoTreasureId);
|
treasureModel.selectedTreasure = gotoTreasureId;
|
treasureModel.currentCategory = (TreasureCategory)config.Category;
|
WindowJumpMgr.Instance.WindowJumpTo(JumpUIType.TreasureCollectSoul);
|
}
|
}
|
|
private void GotoSkyTower()
|
{
|
WindowCenter.Instance.Close<DailyQuestWin>();
|
WindowCenter.Instance.Open<TowerWin>(false, 0);
|
}
|
|
private bool IsTreasureCollectSoul(int _treasureId)
|
{
|
return false;
|
}
|
|
public int GetDailyQuestLV(int id)
|
{
|
var QuestConfig = DailyQuestConfig.Get(id);
|
var LVConfig = FuncOpenLVConfig.Get(QuestConfig.UnLockFuncID);
|
int NeedLV = 0;
|
if (LVConfig.LimitLV != 0)
|
{
|
NeedLV = LVConfig.LimitLV;
|
}
|
else
|
{
|
if (LVConfig.LimitMissionID != 0)
|
{
|
var TaskConfig = PyTaskConfig.Get(LVConfig.LimitMissionID);
|
NeedLV = TaskConfig == null ? NeedLV : TaskConfig.lv;
|
}
|
}
|
return NeedLV;
|
}
|
|
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 NeedLV = GetDailyQuestLV(config.ID);
|
if (!DailyQuestLVList.Contains(NeedLV))
|
{
|
bool bIsAdd = false;
|
for (int i = 0; i < DailyQuestLVList.Count; i++)
|
{
|
if (NeedLV < DailyQuestLVList[i])
|
{
|
DailyQuestLVList.Insert(i, NeedLV);
|
bIsAdd = true;
|
break;
|
}
|
}
|
if (!bIsAdd)
|
{
|
DailyQuestLVList.Add(NeedLV);
|
}
|
|
}
|
|
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);
|
}
|
|
var allRewardKeys = DailyLivenessRewardConfig.GetKeys();
|
m_DailyQuestTotalActiveValue = DailyLivenessRewardConfig.Get(allRewardKeys[allRewardKeys.Count - 1]).Liveness;
|
}
|
|
public enum DailyQuestCategory
|
{
|
EveryDay = 1,
|
TimeLimit = 2,
|
}
|
|
public enum DailyQuestState
|
{
|
Locked = 0,
|
OutTime = 2,
|
Normal = 3,
|
CanBuyTimes = 5,
|
Completed = 6,
|
}
|
}
|
|
}
|
|
|
|
