//--------------------------------------------------------
|
// [Author]: 第二世界
|
// [ Date ]: Monday, October 09, 2017
|
//--------------------------------------------------------
|
using UnityEngine;
|
using System.Collections;
|
using System.Collections.Generic;
|
|
using System;
|
using System.Text.RegularExpressions;
|
|
namespace vnxbqy.UI
|
{
|
|
|
public class TreasureModel : Model, IBeforePlayerDataInitialize, IAfterPlayerDataInitialize, IPlayerLoginOk
|
{
|
Dictionary<int, Treasure> treasures = new Dictionary<int, Treasure>();
|
Dictionary<TreasureCategory, List<int>> treasureCategory = new Dictionary<TreasureCategory, List<int>>();
|
Dictionary<int, int> treasureMapDict = new Dictionary<int, int>();
|
Dictionary<int, TreasureDungeon> treasureDungeons = new Dictionary<int, TreasureDungeon>();
|
Dictionary<int, Dictionary<int, List<int>>> treasureClues = new Dictionary<int, Dictionary<int, List<int>>>();
|
Dictionary<int, List<int>> treasureTasks = new Dictionary<int, List<int>>();
|
Dictionary<TreasureCategory, int> treasureUnlockShowDict = new Dictionary<TreasureCategory, int>();
|
Dictionary<int, int> treasureTaskCompletedCounts = new Dictionary<int, int>();
|
Dictionary<int, int> treasureSignInPropertys = new Dictionary<int, int>();
|
Dictionary<int, List<int>> treasureInductionTasks = new Dictionary<int, List<int>>();
|
List<int> eightFurnacesAchievements = new List<int>();
|
List<int> treasureUnOpens = new List<int>();
|
Dictionary<int, Int2> awardsToFaboClue = new Dictionary<int, Int2>(); //奖励对应的法宝和线索
|
List<int> awardsSort = new List<int>(); // 奖励排序
|
public const int CLIENTDATAMAP = 4000;
|
public const int TREASURE_DATAMAPID = 41110;
|
public const int TREASURE_MAPID = 41110;
|
public const int TREASURE_GUIDE_ID = 102;
|
|
const int TREASURE_REDPOINTID = 7000;
|
public readonly static int[] CATEGORY_REDPOINTIDS = { 7001, 7002, 7003, 7004, 7005 };
|
const int TREASURE_REDPOINTBASE = 7100;
|
|
public static int redpointIndex = 1;
|
|
Redpoint treasureRedpoint = new Redpoint(1, TREASURE_REDPOINTID);
|
Redpoint humanRedpoint = new Redpoint(TREASURE_REDPOINTID, CATEGORY_REDPOINTIDS[(int)TreasureCategory.Human - 1]);
|
Redpoint demonRedpoint = new Redpoint(TREASURE_REDPOINTID, CATEGORY_REDPOINTIDS[(int)TreasureCategory.Demon - 1]);
|
Redpoint fairypoint = new Redpoint(TREASURE_REDPOINTID, CATEGORY_REDPOINTIDS[(int)TreasureCategory.Fairy - 1]);
|
Redpoint elderGodRedpoint = new Redpoint(TREASURE_REDPOINTID, CATEGORY_REDPOINTIDS[(int)TreasureCategory.King - 1]);
|
Redpoint zergRedpoint = new Redpoint(TREASURE_REDPOINTID, CATEGORY_REDPOINTIDS[(int)TreasureCategory.Zerg - 1]);
|
|
public event Action<int> treasureCollectProgressRefresh;
|
public event Action<int> treasureSelectedEvent;
|
public event Action<TreasureCategory> collectingTreasureChangeEvent;
|
public event Action<int> treasureStateChangeEvent;
|
public event Action vipKillNPCTreasureEvent;
|
public event Action<int> treasureStageUpEvent;
|
public event Action<int> demonTreasureDungeonUpdate;
|
public event Action demonDungeonChallengeNext;
|
public event Action<int> onInductionTaskComplete;
|
|
int m_SelectedTreasure = 0;
|
public int selectedTreasure
|
{
|
get { return m_SelectedTreasure; }
|
set
|
{
|
if (m_SelectedTreasure != value)
|
{
|
m_SelectedTreasure = value;
|
if (treasureSelectedEvent != null)
|
{
|
treasureSelectedEvent(m_SelectedTreasure);
|
}
|
}
|
}
|
}
|
|
public bool treasureStageUpShow { get; set; }
|
|
TreasureCategory m_CurrentCategory = TreasureCategory.Human;
|
public TreasureCategory currentCategory
|
{
|
get { return m_CurrentCategory; }
|
set { m_CurrentCategory = value; }
|
}
|
|
int m_CollectingHuman = 0;
|
public int collectingHuman
|
{
|
get { return m_CollectingHuman; }
|
set
|
{
|
if (m_CollectingHuman != value)
|
{
|
m_CollectingHuman = value;
|
if (collectingTreasureChangeEvent != null)
|
{
|
collectingTreasureChangeEvent(TreasureCategory.Human);
|
}
|
}
|
}
|
}
|
|
int m_CollectingDemon = 0;
|
public int collectingDemon
|
{
|
get { return m_CollectingDemon; }
|
set
|
{
|
if (m_CollectingDemon != value)
|
{
|
m_CollectingDemon = value;
|
if (collectingTreasureChangeEvent != null)
|
{
|
collectingTreasureChangeEvent(TreasureCategory.Demon);
|
}
|
}
|
}
|
}
|
|
public Dictionary<int, int> fairyTreasureGetDict { get; private set; }
|
|
public bool isServerReady { get; private set; }
|
public int newGotTreasureId
|
{
|
get { return LocalSave.GetInt(StringUtility.Contact(PlayerDatas.Instance.baseData.PlayerID, "_NewGotTreasureId")); }
|
set { LocalSave.SetInt(StringUtility.Contact(PlayerDatas.Instance.baseData.PlayerID, "_NewGotTreasureId"), value); }
|
}
|
|
public bool newGotShowing
|
{
|
get { return newGotTreasureId > 0; }
|
}
|
|
public int treasureCollectingShowId
|
{
|
get { return LocalSave.GetInt(StringUtility.Contact(PlayerDatas.Instance.baseData.PlayerID, "_TreasureCollectingShowId")); }
|
set { LocalSave.SetInt(StringUtility.Contact(PlayerDatas.Instance.baseData.PlayerID, "_TreasureCollectingShowId"), value); }
|
}
|
|
public int treasureGotoId { get; set; }
|
public bool openFromTreasureList { get; set; }
|
|
public List<int> guideTreasures { get; private set; }
|
|
public int treasureBackLvLimit { get; private set; }
|
public int exitRecord { get; set; }
|
public int entranceOpenCondition { get; private set; }
|
|
public int treasureChapterId { get; set; }
|
|
public int displayInductionId { get; private set; }
|
|
TaskModel taskModel { get { return ModelCenter.Instance.GetModel<TaskModel>(); } }
|
RoleModel roleModel { get { return ModelCenter.Instance.GetModel<RoleModel>(); } }
|
|
VIPKillNPCTreasure m_VIPKillNPCTreasure;
|
public VIPKillNPCTreasure vipKillNPCTreasure
|
{
|
get { return m_VIPKillNPCTreasure; }
|
set
|
{
|
m_VIPKillNPCTreasure = value;
|
if (vipKillNPCTreasureEvent != null)
|
{
|
vipKillNPCTreasureEvent();
|
}
|
}
|
}
|
|
bool playerLevelRefresh = false;
|
bool needDisplayReguluLevelUp = false;
|
|
public int m_jumpAwardID; //跳转奖励ID ，快速领取的奖励ID
|
public int gotoAwardClue; //跳转奖励线索
|
public bool quickGetAward = false; //是否快速领取奖励
|
|
public override void Init()
|
{
|
ParseConfigs();
|
|
PlayerDatas.Instance.playerDataRefreshEvent += PlayerDataRefreshInfoEvent;
|
WindowCenter.Instance.windowAfterOpenEvent += OnWindowOpen;
|
WindowCenter.Instance.windowAfterCloseEvent += OnWindowClose;
|
NewBieCenter.Instance.guideCompletedEvent += GuideComplete;
|
StageLoad.Instance.onStageLoadFinish += OnStageLoadFinish;
|
GlobalTimeEvent.Instance.secondEvent += PerSecond;
|
TaskModel.Event_MainlineTask += OnTaskRefresh;
|
roleModel.OnCustomAwardsEvent += OnCustomAwardsEvent;
|
}
|
|
public void OnBeforePlayerDataInitialize()
|
{
|
isServerReady = false;
|
playerLevelRefresh = false;
|
needDisplayReguluLevelUp = false;
|
treasureUnlockShowDict.Clear();
|
treasureTaskCompletedCounts.Clear();
|
foreach (var treasure in treasures.Values)
|
{
|
treasure.state = TreasureState.Locked;
|
treasure.RefreshLevel(0, 0);
|
}
|
foreach (var treasureDungeon in treasureDungeons.Values)
|
{
|
treasureDungeon.currentLevel = 0;
|
}
|
m_jumpAwardID = -1;
|
gotoAwardClue = -1;
|
quickGetAward = false;
|
}
|
|
public void OnAfterPlayerDataInitialize()
|
{
|
collectingDemon = 0;
|
collectingHuman = 0;
|
}
|
|
public void OnPlayerLoginOk()
|
{
|
isServerReady = true;
|
RefreshDemonDungeonRedpoints();
|
}
|
|
public override void UnInit()
|
{
|
NewBieCenter.Instance.guideCompletedEvent -= GuideComplete;
|
PlayerDatas.Instance.playerDataRefreshEvent -= PlayerDataRefreshInfoEvent;
|
WindowCenter.Instance.windowAfterOpenEvent -= OnWindowOpen;
|
WindowCenter.Instance.windowAfterCloseEvent -= OnWindowClose;
|
StageLoad.Instance.onStageLoadFinish -= OnStageLoadFinish;
|
GlobalTimeEvent.Instance.secondEvent -= PerSecond;
|
TaskModel.Event_MainlineTask -= OnTaskRefresh;
|
roleModel.OnCustomAwardsEvent -= OnCustomAwardsEvent;
|
}
|
|
private void PerSecond()
|
{
|
if (isServerReady)
|
{
|
if (playerLevelRefresh)
|
{
|
playerLevelRefresh = false;
|
RefreshTreasureCollectState();
|
}
|
}
|
}
|
|
private void OnStageLoadFinish()
|
{
|
if (!(StageLoad.Instance.currentStage is DungeonStage))
|
{
|
exitRecord = 0;
|
treasureChapterId = 0;
|
}
|
}
|
|
private void ParseConfigs()
|
{
|
var treasureConfigs = TreasureConfig.GetValues();
|
foreach (var config in treasureConfigs)
|
{
|
var category = (TreasureCategory)config.Category;
|
List<int> categoryTreasures = null;
|
if (!treasureCategory.ContainsKey(category))
|
{
|
treasureCategory[category] = categoryTreasures = new List<int>();
|
}
|
else
|
{
|
categoryTreasures = treasureCategory[category];
|
}
|
|
categoryTreasures.Add(config.ID);
|
Treasure treasure = new Treasure(config.ID);
|
|
treasures[config.ID] = treasure;
|
|
if (!treasureMapDict.ContainsKey(config.ID))
|
{
|
treasureMapDict.Add(config.ID, config.MapId);
|
}
|
|
if (config.ID == 301)
|
{
|
List<int> list = null;
|
SuccessConfig.TryGetTreasureExpAchievements(config.ID, out list);
|
if (list != null)
|
{
|
eightFurnacesAchievements.AddRange(list);
|
}
|
}
|
}
|
|
var treasureUpConfigs = TreasureUpConfig.GetValues();
|
foreach (var config in treasureUpConfigs)
|
{
|
Treasure treasure;
|
if (TryGetTreasure(config.MWID, out treasure))
|
{
|
treasure.ParseStage(config);
|
}
|
}
|
|
var funcConfig = FuncConfigConfig.Get("GuideMission");
|
guideTreasures = new List<int>();
|
guideTreasures.AddRange(ConfigParse.GetMultipleStr<int>(funcConfig.Numerical2));
|
|
funcConfig = FuncConfigConfig.Get("TreasureGetVipLv");
|
fairyTreasureGetDict = ConfigParse.GetDic<int, int>(funcConfig.Numerical1);
|
|
funcConfig = FuncConfigConfig.Get("TreasureSkip");
|
treasureBackLvLimit = int.Parse(funcConfig.Numerical1);
|
|
funcConfig = FuncConfigConfig.Get("TreasureNoOpen");
|
treasureUnOpens.AddRange(ConfigParse.GetMultipleStr<int>(funcConfig.Numerical1));
|
|
funcConfig = FuncConfigConfig.Get("OpenFabao");
|
entranceOpenCondition = int.Parse(funcConfig.Numerical1);
|
|
var treasureDungeonConfigs = TreasureDungeonConfig.GetValues();
|
foreach (var config in treasureDungeonConfigs)
|
{
|
TreasureDungeon treasureDungeon;
|
if (!treasureDungeons.TryGetValue(config.MWID, out treasureDungeon))
|
{
|
var treasureConfig = TreasureConfig.Get(config.MWID);
|
var challengeRedpoint = new Redpoint(CATEGORY_REDPOINTIDS[treasureConfig.Category - 1], TREASURE_REDPOINTBASE + redpointIndex++);
|
treasureDungeon = new TreasureDungeon(config.MWID, challengeRedpoint);
|
treasureDungeons.Add(config.MWID, treasureDungeon);
|
}
|
treasureDungeon.ParseDungeonInfo(config);
|
}
|
|
var taskConfigs = TaskListConfig.GetValues();
|
foreach (var config in taskConfigs)
|
{
|
if (config.FabaoID == 0)
|
{
|
continue;
|
}
|
|
if (config.clue != 0)
|
{
|
Dictionary<int, List<int>> clues = null;
|
if (!treasureClues.TryGetValue(config.FabaoID, out clues))
|
{
|
clues = new Dictionary<int, List<int>>();
|
treasureClues.Add(config.FabaoID, clues);
|
}
|
List<int> tasks = null;
|
if (!clues.TryGetValue(config.clue, out tasks))
|
{
|
tasks = new List<int>();
|
clues.Add(config.clue, tasks);
|
}
|
tasks.Add(config.TaskID);
|
|
if (!treasureTasks.TryGetValue(config.FabaoID, out tasks))
|
{
|
tasks = new List<int>();
|
treasureTasks.Add(config.FabaoID, tasks);
|
}
|
tasks.Add(config.TaskID);
|
|
awardsToFaboClue[config.AwardID] = new Int2(config.FabaoID, config.clue);
|
awardsSort.Add(config.AwardID);
|
}
|
|
|
if (config.induction == 1)
|
{
|
if (!treasureInductionTasks.ContainsKey(config.FabaoID))
|
{
|
treasureInductionTasks.Add(config.FabaoID, new List<int>());
|
}
|
treasureInductionTasks[config.FabaoID].Add(config.TaskID);
|
}
|
}
|
|
funcConfig = FuncConfigConfig.Get("MWSignDayAttr");
|
var jsonData = LitJson.JsonMapper.ToObject(funcConfig.Numerical1);
|
foreach (var _key in jsonData.Keys)
|
{
|
treasureSignInPropertys.Add(int.Parse(_key), int.Parse(jsonData[_key].ToString()));
|
}
|
}
|
|
public void TryOpenRegulusPopWindow()
|
{
|
if (isServerReady)
|
{
|
if (WindowCenter.Instance.IsOpen<MainInterfaceWin>() && !WindowCenter.Instance.ExistAnyFullScreenOrMaskWin())
|
{
|
if (!WindowCenter.Instance.IsOpen<TreasureRegulusPopWin>())
|
{
|
WindowCenter.Instance.Open<TreasureRegulusPopWin>();
|
}
|
needDisplayReguluLevelUp = false;
|
}
|
else
|
{
|
needDisplayReguluLevelUp = true;
|
}
|
}
|
}
|
|
public int IsRequireUnlockAnim(TreasureCategory _type)
|
{
|
if (!treasureUnlockShowDict.ContainsKey(_type))
|
{
|
var _playerId = PlayerDatas.Instance.baseData.PlayerID;
|
var _id = LocalSave.GetInt(StringUtility.Contact(_playerId, _type, "_TreasureUnlockShow"));
|
treasureUnlockShowDict.Add(_type, _id);
|
}
|
return treasureUnlockShowDict[_type];
|
}
|
|
public bool TryGetUnlockShowTreasure(out int _id)
|
{
|
_id = 0;
|
if ((_id = IsRequireUnlockAnim(TreasureCategory.Human)) != 0)
|
{
|
return true;
|
}
|
else if ((_id = IsRequireUnlockAnim(TreasureCategory.Demon)) != 0)
|
{
|
return true;
|
}
|
else if ((_id = IsRequireUnlockAnim(TreasureCategory.Fairy)) != 0)
|
{
|
return true;
|
}
|
return false;
|
}
|
|
public void SetUnlockAnim(TreasureCategory _type, int _id)
|
{
|
if (treasureUnlockShowDict.ContainsKey(_type))
|
{
|
treasureUnlockShowDict[_type] = _id;
|
}
|
var _playerId = PlayerDatas.Instance.baseData.PlayerID;
|
LocalSave.SetInt(StringUtility.Contact(_playerId, _type, "_TreasureUnlockShow"), _id);
|
}
|
|
public bool TryGetTreasure(int _id, out Treasure _treasure)
|
{
|
return treasures.TryGetValue(_id, out _treasure);
|
}
|
|
public bool TryGetTreasureDungeon(int _id, out TreasureDungeon _treasureDungeon)
|
{
|
return treasureDungeons.TryGetValue(_id, out _treasureDungeon);
|
}
|
|
public bool TryGetTreasureDungeon(int _mapId, int lineId, out TreasureDungeon treasureDungeon)
|
{
|
treasureDungeon = null;
|
if (_mapId != 41110)
|
{
|
return false;
|
}
|
var list = GetTreasureCategory(TreasureCategory.Demon);
|
for (int i = 0; i < list.Count; i++)
|
{
|
if (TryGetTreasureDungeon(list[i], out treasureDungeon))
|
{
|
if (treasureDungeon.dungeonInfos.Count > 0)
|
{
|
if (treasureDungeon.dungeonInfos[0].lineId == lineId)
|
{
|
return true;
|
}
|
}
|
}
|
}
|
return false;
|
}
|
|
public bool TryGetTreasureClues(int id, out Dictionary<int, List<int>> clues)
|
{
|
return treasureClues.TryGetValue(id, out clues);
|
}
|
|
public bool TryGetTreasureClueTasks(int id, int clue, out List<int> tasks)
|
{
|
tasks = null;
|
if (treasureClues.ContainsKey(id))
|
{
|
return treasureClues[id].TryGetValue(clue, out tasks);
|
}
|
return false;
|
}
|
|
public bool TryGetTreasureTasks(int id,out List<int> tasks)
|
{
|
return treasureTasks.TryGetValue(id, out tasks);
|
}
|
|
public List<int> GetAllTreasure()
|
{
|
return new List<int>(treasures.Keys);
|
}
|
|
public List<int> GetTreasureCategory(TreasureCategory _category)
|
{
|
if (treasureCategory.ContainsKey(_category))
|
{
|
return treasureCategory[_category];
|
}
|
else
|
{
|
return null;
|
}
|
}
|
|
// 获取下一个法宝ID，不能直接法宝ID + 1，要从表读取
|
public int GetNextTreasureID(int curID, TreasureCategory _category)
|
{
|
var list = GetTreasureCategory(_category);
|
if (list != null)
|
{
|
int index = list.IndexOf(curID);
|
if (index >= 0 && index < list.Count-1)
|
{
|
return list[index + 1];
|
}
|
}
|
|
return 0;
|
}
|
public int GetPreTreasureID(int curID, TreasureCategory _category)
|
{
|
var list = GetTreasureCategory(_category);
|
if (list != null)
|
{
|
int index = list.IndexOf(curID);
|
if (index > 0 && index <= list.Count)
|
{
|
return list[index - 1];
|
}
|
}
|
|
return 0;
|
}
|
|
public int GetCollectedTreasureCount(TreasureCategory _category)
|
{
|
var treasureIds = GetTreasureCategory(_category);
|
var count = 0;
|
foreach (var id in treasureIds)
|
{
|
if (treasures[id].state == TreasureState.Collected)
|
{
|
count++;
|
}
|
}
|
return count;
|
}
|
|
public int GetCompleteTaskCount(int id)
|
{
|
var count = 0;
|
Dictionary<int, List<int>> clues = null;
|
if (TryGetTreasureClues(id, out clues))
|
{
|
var taskId = taskModel.GetLatestMainTaskId();
|
var taskState = taskModel.GetQuestState(taskId);
|
var clueCount = 0;
|
foreach (var clue in clues.Keys)
|
{
|
clueCount++;
|
List<int> tasks = clues[clue];
|
var lastTask = tasks[tasks.Count - 1];
|
if (taskId > lastTask)
|
{
|
count = clueCount;
|
}
|
else if (taskId == lastTask && taskState == 3)
|
{
|
count = clueCount;
|
}
|
}
|
count = Mathf.Min(count, clues.Count);
|
}
|
return count;
|
}
|
|
public int GetTreasureIdByMapIdAndLineId(int _mapId, int _lineId)
|
{
|
var dungeonModel = ModelCenter.Instance.GetModel<DungeonModel>();
|
var dataMapId = dungeonModel.GetDataMapIdByMapId(_mapId);
|
var allConfigs = TreasureConfig.GetValues();
|
foreach (var config in allConfigs)
|
{
|
if (config.MapId == dataMapId && config.LineId == _lineId)
|
{
|
return config.ID;
|
}
|
}
|
|
return 0;
|
}
|
|
public int GetTreasureBySkillId(int skillId)
|
{
|
foreach (var id in treasures.Keys)
|
{
|
if (treasures[id].skillId == skillId)
|
{
|
return id;
|
}
|
}
|
return 0;
|
}
|
|
public List<int> GetFurnacesAchievements()
|
{
|
return eightFurnacesAchievements;
|
}
|
|
public Dictionary<int, int> GetSignInPropertys()
|
{
|
return treasureSignInPropertys;
|
}
|
|
private void PlayerDataRefreshInfoEvent(PlayerDataType refreshType)
|
{
|
switch (refreshType)
|
{
|
case PlayerDataType.LV:
|
playerLevelRefresh = true;
|
break;
|
case PlayerDataType.FightPoint:
|
case PlayerDataType.FightPower:
|
case PlayerDataType.DEF:
|
RefreshDemonDungeonRedpoints();
|
break;
|
}
|
}
|
|
private void RefreshTreasureCollectState()
|
{
|
RefreshTreasureCollectState(TreasureCategory.Human);
|
RefreshTreasureCollectState(TreasureCategory.Demon);
|
}
|
|
private void RefreshTreasureCollectState(TreasureCategory category)
|
{
|
var treasureIds = GetTreasureCategory(category);
|
foreach (var id in treasureIds)
|
{
|
var treasure = treasures[id];
|
if (treasure.state != TreasureState.Locked)
|
{
|
continue;
|
}
|
var config = TreasureConfig.Get(id);
|
if (config.PreTreasure != 0 && treasures[config.PreTreasure].state != TreasureState.Collected)
|
{
|
continue;
|
}
|
var satisfyCollect = false;
|
switch (category)
|
{
|
case TreasureCategory.Human:
|
{
|
List<int> tasks;
|
if (TryGetTreasureTasks(id, out tasks))
|
{
|
var firstTask = tasks[0];
|
var taskId = taskModel.GetLatestMainTaskId();
|
var taskState = taskModel.GetQuestState(taskId);
|
if (taskId >= firstTask)
|
{
|
satisfyCollect = true;
|
collectingHuman = id;
|
}
|
}
|
}
|
break;
|
case TreasureCategory.Demon:
|
{
|
if (PlayerDatas.Instance.baseData.LV >= config.ChallengeLevel)
|
{
|
satisfyCollect = true;
|
collectingDemon = id;
|
}
|
}
|
break;
|
}
|
|
if (satisfyCollect)
|
{
|
if (isServerReady)
|
{
|
SetUnlockAnim((TreasureCategory)config.Category, id);
|
}
|
treasure.state = TreasureState.Collecting;
|
if (category == TreasureCategory.Demon)
|
{
|
RefreshDemonDungeonRedpoint(id);
|
}
|
}
|
|
if (treasureStateChangeEvent != null)
|
{
|
treasureStateChangeEvent(id);
|
}
|
}
|
}
|
|
private void RefreshDemonDungeonRedpoints()
|
{
|
foreach (var treasureId in treasureDungeons.Keys)
|
{
|
RefreshDemonDungeonRedpoint(treasureId);
|
}
|
}
|
|
private void RefreshDemonDungeonRedpoint(int treasureId)
|
{
|
TreasureDungeon treasureDungeon;
|
if (TryGetTreasureDungeon(treasureId, out treasureDungeon))
|
{
|
treasureDungeon.challengeRedpoint.state = RedPointState.None;
|
Treasure treasure;
|
if (TryGetTreasure(treasureId, out treasure)
|
&& treasure.state != TreasureState.Collecting)
|
{
|
return;
|
}
|
var dungeonInfo = treasureDungeon.Get(treasureDungeon.currentLevel + 1);
|
if (!dungeonInfo.Equals(default(TreasureDungeonInfo)))
|
{
|
if (PlayerDatas.Instance.baseData.FightPoint >= (ulong)dungeonInfo.fightPower
|
&& (int)UIHelper.GetPropertyValue(PropertyType.DEF) >= dungeonInfo.defense)
|
{
|
treasureDungeon.challengeRedpoint.state = RedPointState.Simple;
|
}
|
}
|
}
|
}
|
|
#region 法宝新获得表现
|
private void OnWindowOpen(Window _window)
|
{
|
if (_window is MainInterfaceWin)
|
{
|
SnxxzGame.Instance.StartCoroutine(Co_OpenTreasureNewGot());
|
if (needDisplayReguluLevelUp)
|
{
|
TryOpenRegulusPopWindow();
|
}
|
}
|
}
|
|
private void OnWindowClose(Window win)
|
{
|
if (win is LoginAdWin)
|
{
|
SnxxzGame.Instance.StartCoroutine(Co_OpenTreasureNewGot());
|
}
|
}
|
|
void GuideComplete(int _id)
|
{
|
if (newGotTreasureId != 0)
|
{
|
SnxxzGame.Instance.StartCoroutine(Co_OpenTreasureNewGot());
|
}
|
}
|
|
public void TryOpenNewGotTreasureWin()
|
{
|
SnxxzGame.Instance.StartCoroutine(Co_OpenTreasureNewGot());
|
}
|
|
IEnumerator Co_OpenTreasureNewGot()
|
{
|
yield return null;
|
OpenTreasureNewGot();
|
}
|
|
private void OpenTreasureNewGot()
|
{
|
if (!(StageLoad.Instance.currentStage is DungeonStage) || !isServerReady)
|
{
|
return;
|
}
|
if (!PreFightMission.Instance.IsFinished() || newGotTreasureId == 0
|
|| NewBieCenter.Instance.inGuiding || !WindowCenter.Instance.IsOpen<MainInterfaceWin>()
|
|| WindowCenter.Instance.ExistAnyFullScreenOrMaskWinLEqual(WindowType.Base)
|
|| WindowCenter.Instance.IsOpen<TreasureNewGotWin>())
|
{
|
return;
|
}
|
var dungeonModel = ModelCenter.Instance.GetModel<DungeonModel>();
|
var mapConfig = MapConfig.Get(PlayerDatas.Instance.baseData.MapID);
|
if (mapConfig == null || mapConfig.MapFBType != (int)MapType.OpenCountry)
|
{
|
return;
|
}
|
WindowCenter.Instance.Open<TreasureNewGotWin>();
|
}
|
#endregion
|
|
public void ReceivePackage(HA352_tagMCMagicWeaponLVInfo package)
|
{
|
for (int i = 0; i < package.Count; i++)
|
{
|
var data = package.InfoList[i];
|
|
Treasure treasure;
|
if (TryGetTreasure((int)data.MWID, out treasure))
|
{
|
bool levelUp = false;
|
|
if (treasure.level < data.LV)
|
{
|
levelUp = true;
|
}
|
|
treasure.RefreshLevel(data.LV, (int)data.Exp);
|
|
if (isServerReady && levelUp && treasureStageUpEvent != null)
|
{
|
treasureStageUpEvent(treasure.id);
|
}
|
}
|
|
if (treasure.level > 0 && treasure.state != TreasureState.Collected)
|
{
|
treasure.state = TreasureState.Collected;
|
var config = TreasureConfig.Get(treasure.id);
|
if (IsRequireUnlockAnim((TreasureCategory)config.Category) == treasure.id)
|
{
|
SetUnlockAnim((TreasureCategory)config.Category, 0);
|
}
|
if (isServerReady)
|
{
|
newGotTreasureId = treasure.id;
|
OpenTreasureNewGot();
|
}
|
if (treasureCollectingShowId == treasure.id)
|
{
|
treasureCollectingShowId = 0;
|
}
|
if (treasureStateChangeEvent != null)
|
{
|
treasureStateChangeEvent(treasure.id);
|
}
|
}
|
|
TreasureDungeon treasureDungeon;
|
if (TryGetTreasureDungeon((int)data.MWID, out treasureDungeon))
|
{
|
treasureDungeon.currentLevel = data.FBPassLV;
|
RefreshDemonDungeonRedpoint(treasureDungeon.treasureId);
|
if (demonTreasureDungeonUpdate != null)
|
{
|
demonTreasureDungeonUpdate(treasureDungeon.treasureId);
|
}
|
}
|
}
|
|
RefreshTreasureCollectState();
|
}
|
|
|
void OnCustomAwardsEvent()
|
{
|
m_jumpAwardID = -1;
|
foreach (var awardID in awardsSort)
|
{
|
if (roleModel.GetCustomAwardState(awardID) == 1)
|
{
|
m_jumpAwardID = awardID;
|
break;
|
}
|
}
|
}
|
|
public Int2 GetFabaoAwardInfo(int awardID)
|
{
|
Int2 fabaoInfo;
|
if (awardsToFaboClue.TryGetValue(awardID, out fabaoInfo))
|
{
|
return fabaoInfo;
|
}
|
return new Int2(0, 0);
|
}
|
|
|
private void OnTaskRefresh(int MissionID, int MissionState)
|
{
|
RefreshTreasureCollectState(TreasureCategory.Human);
|
|
var treasureIds = GetTreasureCategory(TreasureCategory.Human);
|
foreach (var id in treasureIds)
|
{
|
var count = GetCompleteTaskCount(id);
|
|
if (!treasureTaskCompletedCounts.ContainsKey(id)
|
|| treasureTaskCompletedCounts[id] != count)
|
{
|
treasureTaskCompletedCounts[id] = count;
|
if (treasureCollectProgressRefresh != null)
|
{
|
treasureCollectProgressRefresh(id);
|
}
|
}
|
}
|
}
|
|
public bool IsVersionUnOpenTreasure(int _id)
|
{
|
return treasureUnOpens.Contains(_id);
|
}
|
|
public int GetMapIdByTreasure(int _treasureId)
|
{
|
if (treasureMapDict.ContainsKey(_treasureId))
|
{
|
return treasureMapDict[_treasureId];
|
}
|
return 0;
|
}
|
|
public bool IsTreasureCollected(int _treasureId)
|
{
|
Treasure treasure;
|
if (TryGetTreasure(_treasureId, out treasure))
|
{
|
return treasure.state == TreasureState.Collected;
|
}
|
return false;
|
}
|
|
public int GetTreasureFightPower(int _treasureId, bool _real = true)
|
{
|
Treasure treasure;
|
if (!TryGetTreasure(_treasureId, out treasure))
|
{
|
return 0;
|
}
|
var _fightPower = 0;
|
if (treasure.state != TreasureState.Collected)
|
{
|
return _fightPower;
|
}
|
for (int i = 0; i < treasure.treasureStages.Count; i++)
|
{
|
var _stage = treasure.treasureStages[i];
|
if (_real && treasure.level < _stage.stage)
|
{
|
break;
|
}
|
_fightPower += _stage.GetFightPower();
|
_fightPower += _stage.powerEx;
|
}
|
_fightPower += GetExtensionPower(_treasureId);
|
return _fightPower;
|
}
|
|
public int GetExtensionPower(int _treasureId)
|
{
|
return 0;
|
}
|
|
public bool SatisfyChallenge(int id)
|
{
|
if (treasures.ContainsKey(id))
|
{
|
var treasure = treasures[id];
|
var config = TreasureConfig.Get(id);
|
switch ((TreasureCategory)config.Category)
|
{
|
case TreasureCategory.Human:
|
{
|
if (treasure.state != TreasureState.Collecting)
|
{
|
return false;
|
}
|
List<int> tasks = null;
|
if (TryGetTreasureTasks(id, out tasks))
|
{
|
var lastTask = tasks[tasks.Count - 1];
|
var taskId = taskModel.GetLatestMainTaskId();
|
var taskState = taskModel.GetQuestState(taskId);
|
if (taskId > lastTask || (taskId == lastTask && taskState == 3))
|
{
|
return true;
|
}
|
}
|
}
|
break;
|
}
|
}
|
return false;
|
}
|
|
public bool SatisfyEntranceOpen()
|
{
|
var list = GetTreasureCategory(TreasureCategory.Human);
|
if (list != null && list.Count > 1)
|
{
|
if (treasures.ContainsKey(list[1]))
|
{
|
if (treasures[list[1]].state != TreasureState.Locked)
|
{
|
return true;
|
}
|
}
|
}
|
var taskModel = ModelCenter.Instance.GetModel<TaskModel>();
|
var missions = taskModel.MainTaskDic;
|
if (missions != null)
|
{
|
foreach (var missionId in missions.Keys)
|
{
|
if (missionId > entranceOpenCondition)
|
{
|
return true;
|
}
|
else if (missionId == entranceOpenCondition)
|
{
|
return missions[missionId].MissionState == 3;
|
}
|
}
|
return false;
|
}
|
return true;
|
}
|
|
public void DisplayEntranceLimitHint()
|
{
|
var taskConfig = PyTaskConfig.Get(entranceOpenCondition);
|
if (taskConfig != null)
|
{
|
SysNotifyMgr.Instance.ShowTip("OpenFabaoHint", taskConfig.lv);
|
}
|
}
|
|
public void DemonDungeonChallengeNext(int lineId)
|
{
|
CA508_tagCMDoFBAction pak = new CA508_tagCMDoFBAction();
|
pak.ActionType = 0;
|
pak.ActionInfo = 0;
|
GameNetSystem.Instance.SendInfo(pak);
|
var dungeonModel = ModelCenter.Instance.GetModel<DungeonModel>();
|
dungeonModel.UpdateCoolDown(DungeonCoolDownType.LeaveMap, 0);
|
dungeonModel.UpdateCoolDown(DungeonCoolDownType.FightStart, 0);
|
WindowCenter.Instance.Close<DemonTreasureDungeonVictoryWin>();
|
|
TreasureDungeon treasureDungeon;
|
if (TryGetTreasureDungeon(41110, lineId, out treasureDungeon))
|
{
|
if (treasureDungeon.currentLevel == treasureDungeon.maxLevel - 1)
|
{
|
BossShowModel.Instance.StartBossShow(41110, lineId);
|
}
|
}
|
|
if (demonDungeonChallengeNext != null)
|
{
|
demonDungeonChallengeNext();
|
}
|
}
|
|
public void ReceivePackage(H0827_tagMissionDesc vNetData)
|
{
|
if (isServerReady)
|
{
|
|
}
|
}
|
|
public void ReceivePackage(H0823_tagDelMission package)
|
{
|
if (isServerReady)
|
{
|
foreach (var id in treasureInductionTasks.Keys)
|
{
|
if (treasureInductionTasks[id].Contains((int)package.MissionID))
|
{
|
if (onInductionTaskComplete != null)
|
{
|
displayInductionId = (int)package.MissionID;
|
onInductionTaskComplete(id);
|
}
|
break;
|
}
|
}
|
|
TryShowTreasureChapter((int)package.MissionID);
|
}
|
}
|
|
public bool TryGetLatestInductionTask(int id, out int taskId)
|
{
|
taskId = 0;
|
var latestTask = taskModel.GetLatestMainTaskId();
|
if (treasureInductionTasks.ContainsKey(id))
|
{
|
var count = treasureInductionTasks[id].Count;
|
foreach (var _taskId in treasureInductionTasks[id])
|
{
|
if (latestTask <= _taskId)
|
{
|
taskId = _taskId;
|
return true;
|
}
|
}
|
taskId = treasureInductionTasks[id][count - 1];
|
return true;
|
}
|
return false;
|
}
|
|
public int GetTreasureInductionState(int treasurId)
|
{
|
if (treasures[treasurId].state == TreasureState.Collected)
|
{
|
return 1;
|
}
|
var latestTask = taskModel.GetLatestMainTaskId();
|
var inductionTask = 0;
|
if (TryGetLatestInductionTask(treasurId, out inductionTask))
|
{
|
return latestTask.CompareTo(inductionTask);
|
}
|
return 1;
|
}
|
|
public int GetClueState(int treasureId,int clue)
|
{
|
var treasure = treasures[treasureId];
|
if (treasure.state == TreasureState.Collected)
|
{
|
return 2;
|
}
|
else
|
{
|
var taskId = taskModel.GetLatestMainTaskId();
|
var taskState = taskModel.GetQuestState(taskId);
|
Dictionary<int, List<int>> clues;
|
if(TryGetTreasureClues(treasureId, out clues))
|
{
|
var tasks = clues[clue];
|
var lastTask = tasks[tasks.Count - 1];
|
if (taskId > lastTask || (taskId == lastTask && taskState == 3))
|
{
|
return 2;
|
}
|
else
|
{
|
if (tasks.Contains(taskId))
|
{
|
return 1;
|
}
|
}
|
}
|
}
|
return 0;
|
}
|
|
void TryShowTreasureChapter(int taskId)
|
{
|
var configs = TreasureChapterConfig.GetValues();
|
foreach (var config in configs)
|
{
|
if (config.taskId == taskId)
|
{
|
treasureChapterId = config.id;
|
PopupWindowsProcessor.Instance.Add("TreasureChapterWin");
|
break;
|
}
|
}
|
}
|
}
|
|
}
|
|
|
|
