//--------------------------------------------------------
|
// [Author]: 第二世界
|
// [ Date ]: Monday, October 09, 2017
|
//--------------------------------------------------------
|
using UnityEngine;
|
using System.Collections;
|
using System.Collections.Generic;
|
|
using System;
|
using System.Text.RegularExpressions;
|
|
namespace Snxxz.UI
|
{
|
|
[XLua.LuaCallCSharp]
|
public class TreasureModel : Model, IBeforePlayerDataInitialize, IAfterPlayerDataInitialize, IPlayerLoginOk
|
{
|
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(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 Redpoint stoveRedpoint { get; private set; }
|
|
public event Action<int> treasureCollectProgressUpdateEvent;
|
public event Action<int> treasureSelectedEvent;
|
public event Action<int> potentialBookSelectEvent;
|
public event Action<TreasureCategory> collectingTreasureChangeEvent;
|
public event Action<int> treasureStateChangeEvent;
|
public event Action<int, int, bool> onPotentialLevelUpResultEvent;
|
public event Action<int, int> potentialLevelChangeEvent;
|
public event Action<int, int> potentialLevelUpdate;
|
public event Action vipKillNPCTreasureEvent;
|
public event Action<int> treasureLevelProgressUpdateEvent;
|
public event Action<int> treasureStageUpEvent;
|
public event Action<int> humanTreasureStateChangeEvent;
|
public event Action<int> demonTreasureDungeonUpdate;
|
public event Action skillLevelUpRedpointUpdate;
|
public event Action demonDungeonChallengeNext;
|
|
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);
|
}
|
}
|
}
|
}
|
|
int m_SelectedPotential = 0;
|
public int selectedPotential {
|
get { return m_SelectedPotential; }
|
set {
|
if (m_SelectedPotential != value)
|
{
|
m_SelectedPotential = value;
|
}
|
}
|
}
|
|
public bool treasureStepUpShow { get; set; }
|
|
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);
|
}
|
}
|
}
|
}
|
|
int m_SelectedPotentialBook = 0;
|
public int selectedPotentialBook {
|
get { return m_SelectedPotentialBook; }
|
set {
|
if (m_SelectedPotentialBook != value)
|
{
|
m_SelectedPotentialBook = value;
|
if (potentialBookSelectEvent != null)
|
{
|
potentialBookSelectEvent(m_SelectedPotentialBook);
|
}
|
}
|
}
|
}
|
|
int levelUpTreasureIdBuf = 0;
|
int levelUpPotentialBuf = 0;
|
|
Dictionary<int, List<int>> skillLevelUpTypes = new Dictionary<int, List<int>>();
|
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, int> treasureAchievementDict = new Dictionary<int, int>();
|
List<int> eightFurnacesAchievements = new List<int>();
|
List<int> m_CacheGotAchievements = new List<int>();
|
Dictionary<int, int> treasureStageShowDict = new Dictionary<int, int>();
|
List<int> treasureUnOpens = new List<int>();//版本未开放法宝
|
Dictionary<int, int[]> potentialInitialPowers = new Dictionary<int, int[]>();
|
Dictionary<int, TreasureDungeon> treasureDungeons = new Dictionary<int, TreasureDungeon>();
|
List<int> potentialNextTargetLevels = new List<int>();
|
|
public Dictionary<int, int> fairyTreasureGetDict { get; private set; }
|
|
public bool serverInited { 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 treasureEntranceShowId {
|
get { return LocalSave.GetInt(StringUtility.Contact(PlayerDatas.Instance.baseData.PlayerID, "_TreasureEntranceShowId")); }
|
set { LocalSave.SetInt(StringUtility.Contact(PlayerDatas.Instance.baseData.PlayerID, "_TreasureEntranceShowId"), value); }
|
}
|
|
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); }
|
}
|
|
bool potentialFuncOpen { get; set; }
|
|
public int treasureGotoId { get; set; }
|
|
public bool openFromTreasureSoul { get; set; }
|
public bool openFromTreasureUnlockShow { get; set; }
|
public bool openFromTreasureCollect { get; set; }
|
public bool openFromTreasureList { get; set; }
|
public int openFromTaskId { get; set; }
|
public bool inPotentialModifyPower { get; set; }
|
|
public List<int> castSoulGuideTaskIds { get; private set; }
|
public List<int> guideTreasures { get; private set; }
|
|
public int treasureBackLvLimit { get; private set; }
|
public float treasureBackPercent { get; private set; }
|
public int treasureExitLvLimit { get; private set; }
|
public int exitRecord { get; set; }
|
public int entranceOpenCondition { get; private set; }
|
|
public List<int> cacheGotAchievements { get { return m_CacheGotAchievements; } }
|
|
AchievementModel achievementModel { get { return ModelCenter.Instance.GetModel<AchievementModel>(); } }
|
PackModel packageModel { get { return ModelCenter.Instance.GetModel<PackModel>(); } }
|
|
VIPKillNPCTreasure m_VIPKillNPCTreasure;
|
public VIPKillNPCTreasure vipKillNPCTreasure {
|
get { return m_VIPKillNPCTreasure; }
|
set {
|
m_VIPKillNPCTreasure = value;
|
if (vipKillNPCTreasureEvent != null)
|
{
|
vipKillNPCTreasureEvent();
|
}
|
}
|
}
|
|
bool playerLevelRefresh = false;
|
|
public override void Init()
|
{
|
ParseConfigs();
|
ParseSkillLevelUpConfig();
|
ParsePotentialSkillConfig();
|
|
achievementModel.achievementProgressUpdateEvent += OnAchievementProgressUpdate;
|
achievementModel.achievementAwardableEvent += OnAchievementAwardable;
|
achievementModel.achievementCompletedEvent += OnAchievementCompleted;
|
|
DTC0721_tagMakeItemAnswer.MakeItemAnswerEvent += OnGetSkillLevelUpResult;
|
PlayerDatas.Instance.PlayerDataRefreshInfoEvent += OnTreasurePotentialSPChange;
|
FuncOpen.Instance.OnFuncStateChangeEvent += OnFunctionStateChange;
|
packageModel.refreshItemCountEvent += OnPackageItemChange;
|
WindowCenter.Instance.windowAfterOpenEvent += OnWindowOpen;
|
WindowCenter.Instance.windowAfterCloseEvent += OnWindowClose;
|
NewBieCenter.Instance.guideCompletedEvent += GuideComplete;
|
StageLoad.Instance.onStageLoadFinish += OnStageLoadFinish;
|
GlobalTimeEvent.Instance.secondEvent += PerSecond;
|
}
|
|
public override void UnInit()
|
{
|
achievementModel.achievementProgressUpdateEvent -= OnAchievementProgressUpdate;
|
achievementModel.achievementAwardableEvent -= OnAchievementAwardable;
|
achievementModel.achievementCompletedEvent -= OnAchievementCompleted;
|
NewBieCenter.Instance.guideCompletedEvent -= GuideComplete;
|
|
DTC0721_tagMakeItemAnswer.MakeItemAnswerEvent -= OnGetSkillLevelUpResult;
|
PlayerDatas.Instance.PlayerDataRefreshInfoEvent -= OnTreasurePotentialSPChange;
|
FuncOpen.Instance.OnFuncStateChangeEvent -= OnFunctionStateChange;
|
packageModel.refreshItemCountEvent -= OnPackageItemChange;
|
WindowCenter.Instance.windowAfterOpenEvent -= OnWindowOpen;
|
WindowCenter.Instance.windowAfterCloseEvent -= OnWindowClose;
|
StageLoad.Instance.onStageLoadFinish -= OnStageLoadFinish;
|
GlobalTimeEvent.Instance.secondEvent -= PerSecond;
|
}
|
|
private void PerSecond()
|
{
|
if (serverInited)
|
{
|
if (playerLevelRefresh)
|
{
|
UpdateAchievementRedpoints();
|
playerLevelRefresh = false;
|
}
|
}
|
}
|
|
public void OnAfterPlayerDataInitialize()
|
{
|
collectingDemon = 0;
|
collectingHuman = 0;
|
}
|
|
public void OnBeforePlayerDataInitialize()
|
{
|
serverInited = false;
|
playerLevelRefresh = false;
|
needDisplayReguluLevelUp = false;
|
potentialFuncOpen = false;
|
treasureUnlockShowDict.Clear();
|
cacheGotAchievements.Clear();
|
foreach (var treasure in treasures.Values)
|
{
|
treasure.state = TreasureState.Locked;
|
treasure.UpdateTreasureLevelExp(0, 0, false);
|
treasure.ResetPotentialLevel();
|
if ((treasure is HumanTreasure))
|
{
|
var humanTreasure = treasure as HumanTreasure;
|
humanTreasure.UpdateTreasureState();
|
}
|
}
|
foreach (var treasureDungeon in treasureDungeons.Values)
|
{
|
treasureDungeon.currentLevel = 0;
|
}
|
}
|
|
public void OnPlayerLoginOk()
|
{
|
serverInited = true;
|
UpdateAchievementRedpoints();
|
UpdateCastSoulRedpoints();
|
UpdateSkillLevelUpRedpoints();
|
UpdateDemonDungeonRedpoints();
|
}
|
|
private bool needDisplayReguluLevelUp = false;
|
public void CheckReguluPop()
|
{
|
if (serverInited)
|
{
|
if (WindowCenter.Instance.IsOpen<MainInterfaceWin>() && !WindowCenter.Instance.ExistAnyFullScreenOrMaskWin())
|
{
|
if (!WindowCenter.Instance.IsOpen<TreasureRegulusPopWin>())
|
{
|
WindowCenter.Instance.Open<TreasureRegulusPopWin>();
|
}
|
needDisplayReguluLevelUp = false;
|
}
|
else
|
{
|
needDisplayReguluLevelUp = true;
|
}
|
}
|
}
|
|
private void OnStageLoadFinish()
|
{
|
if (!(StageLoad.Instance.currentStage is DungeonStage))
|
{
|
exitRecord = 0;
|
}
|
}
|
|
Dictionary<TreasureCategory, int> treasureUnlockShowDict = new Dictionary<TreasureCategory, int>();
|
public int GetTreasureUnlockShow(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 GetPotentialUnlockShow(int _treasureId)
|
{
|
Treasure treasure;
|
if (TryGetTreasure(_treasureId, out treasure))
|
{
|
var potential = treasure.GetPotentialByIndex(1);
|
if (potential != null && IsPotentialUnlock(_treasureId, potential.id))
|
{
|
SetPotentialUnlockShow(_treasureId);
|
return false;
|
}
|
}
|
var _playerId = PlayerDatas.Instance.baseData.PlayerID;
|
return LocalSave.GetBool(StringUtility.Contact(_playerId, "_PotentialUnlockShow_", _treasureId));
|
}
|
|
public void SetPotentialUnlockShow(int _treasureId, bool _value = false)
|
{
|
var _playerId = PlayerDatas.Instance.baseData.PlayerID;
|
LocalSave.SetBool(StringUtility.Contact(_playerId, "_PotentialUnlockShow_", _treasureId), _value);
|
}
|
|
public bool GetSpAnim(int _treasureId)
|
{
|
var list = GetTreasureCategory(TreasureCategory.Human);
|
var index = list.IndexOf(_treasureId);
|
if (index == -1)
|
{
|
return false;
|
}
|
Treasure treasure;
|
if (TryGetTreasure(_treasureId, out treasure))
|
{
|
var potential = treasure.GetPotentialByIndex(1);
|
if (potential != null && IsPotentialUnlock(_treasureId, potential.id))
|
{
|
SetSpAnim(_treasureId);
|
return true;
|
}
|
}
|
uint value = 0;
|
uint.TryParse(QuickSetting.Instance.GetQuickSetting(QuickSetting.QuickSettingType.SpAnim, 0), out value);
|
return MathUtility.GetBitValue(value, (ushort)index);
|
}
|
|
public void SetSpAnim(int _treasureId, bool anim = true)
|
{
|
var list = GetTreasureCategory(TreasureCategory.Human);
|
var index = list.IndexOf(_treasureId);
|
if (index == -1)
|
{
|
return;
|
}
|
uint value = 0;
|
uint.TryParse(QuickSetting.Instance.GetQuickSetting(QuickSetting.QuickSettingType.SpAnim, 0), out value);
|
int bitValue = MathUtility.SetBitValue((int)value, (ushort)index, anim);
|
QuickSetting.Instance.SetQuickSetting(QuickSetting.QuickSettingType.SpAnim, bitValue);
|
QuickSetting.Instance.SendPackage();
|
}
|
|
public bool GetTreasureFinishAnim(int _treasureId)
|
{
|
if (_treasureId == 101)
|
{
|
return false;
|
}
|
var list = GetTreasureCategory(TreasureCategory.Human);
|
var index = list.IndexOf(_treasureId);
|
if (index == -1)
|
{
|
return false;
|
}
|
uint value = 0;
|
uint.TryParse(QuickSetting.Instance.GetQuickSetting(QuickSetting.QuickSettingType.TreasureHighestAnim, 0), out value);
|
return MathUtility.GetBitValue(value, (ushort)index);
|
}
|
|
public void SetTreasureFinishAnim(int _treasureId, bool anim = true)
|
{
|
var list = GetTreasureCategory(TreasureCategory.Human);
|
var index = list.IndexOf(_treasureId);
|
if (index == -1)
|
{
|
return;
|
}
|
uint value = 0;
|
uint.TryParse(QuickSetting.Instance.GetQuickSetting(QuickSetting.QuickSettingType.TreasureHighestAnim, 0), out value);
|
int bitValue = MathUtility.SetBitValue((int)value, (ushort)index, anim);
|
QuickSetting.Instance.SetQuickSetting(QuickSetting.QuickSettingType.TreasureHighestAnim, bitValue);
|
QuickSetting.Instance.SendPackage();
|
}
|
|
public bool TryGetUnlockShowTreasure(out int _id)
|
{
|
_id = 0;
|
if ((_id = GetTreasureUnlockShow(TreasureCategory.Human)) != 0)
|
{
|
return true;
|
}
|
else if ((_id = GetTreasureUnlockShow(TreasureCategory.Demon)) != 0)
|
{
|
return true;
|
}
|
else if ((_id = GetTreasureUnlockShow(TreasureCategory.Fairy)) != 0)
|
{
|
return true;
|
}
|
return false;
|
}
|
|
public void SetTreasureUnlockShow(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 void SetTreasureStageShow(int _id, int _stage)
|
{
|
LocalSave.SetInt(StringUtility.Contact(PlayerDatas.Instance.baseData.PlayerID,
|
"_TreasureStageShow_", _id), _stage);
|
}
|
|
public int GetTreasureStageShow(int _id)
|
{
|
var _stage = LocalSave.GetInt(StringUtility.Contact(PlayerDatas.Instance.baseData.PlayerID,
|
"_TreasureStageShow_", _id), -1);
|
return _stage;
|
}
|
|
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 TryGetTreasureUnlockAchievement(int _treasureId, out int achievement)
|
{
|
return treasureAchievementDict.TryGetValue(_treasureId, out achievement);
|
}
|
|
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;
|
}
|
}
|
|
public int GetActiveTreasureCategory(TreasureCategory _category)
|
{
|
var list = GetTreasureCategory(_category);
|
if (list == null)
|
{
|
return 0;
|
}
|
|
var count = 0;
|
for (int i = 0; i < list.Count; i++)
|
{
|
Treasure treasure;
|
if (TryGetTreasure(list[i], out treasure) && treasure.state == TreasureState.Collected)
|
{
|
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;
|
}
|
|
/// <summary>
|
/// 获得技能的升级类型
|
/// </summary>
|
/// <param name="_skillId"></param>
|
/// <returns></returns>
|
public int GetSkillLevelUpType(int _skillId)
|
{
|
foreach (var key in skillLevelUpTypes.Keys)
|
{
|
if (skillLevelUpTypes[key].Contains(_skillId))
|
{
|
return key;
|
}
|
}
|
|
return 0;
|
}
|
|
public void RequestPotentialUpgrade(int _treasureId, int _potentialId, int _costIndex)
|
{
|
levelUpTreasureIdBuf = _treasureId;
|
levelUpPotentialBuf = _potentialId;
|
|
var info = new CA50D_tagCMMagicWeaponSkillUp();
|
info.SkillTypeID = (ushort)_potentialId;
|
info.CostIndex = (byte)_costIndex;
|
|
GameNetSystem.Instance.SendInfo(info);
|
}
|
|
public void UpdateTreasureCollectState(uint[] _gotTreasures)
|
{
|
for (int i = 0; i < _gotTreasures.Length; i++)
|
{
|
var id = (int)_gotTreasures[i];
|
Treasure treasure;
|
if (TryGetTreasure(id, out treasure))
|
{
|
if (treasure.state != TreasureState.Collected)
|
{
|
treasure.state = TreasureState.Collected;
|
if (treasure is HumanTreasure)
|
{
|
var humanTreasure = treasure as HumanTreasure;
|
humanTreasure.UpdateTreasureState();
|
UpdateCastSoulRedpoint(treasure.id);
|
if (GetTreasureUnlockShow(TreasureCategory.Human) == treasure.id)
|
{
|
SetTreasureUnlockShow(TreasureCategory.Human, 0);
|
}
|
}
|
if (serverInited)
|
{
|
newGotTreasureId = id;
|
treasureEntranceShowId = id;
|
|
OpenTreasureNewGot();
|
}
|
|
UpdateDemonDungeonRedpoint(treasure.id);
|
|
if (treasureCollectingShowId == id)
|
{
|
treasureCollectingShowId = 0;
|
}
|
|
if (treasureStateChangeEvent != null)
|
{
|
treasureStateChangeEvent(id);
|
}
|
}
|
}
|
}
|
|
foreach (var key in treasures.Keys)
|
{
|
var treasure = treasures[key];
|
if (treasure.state != TreasureState.Locked)
|
{
|
continue;
|
}
|
|
var config = TreasureConfig.Get(key);
|
if (config.PreTreasure == 0 || treasures[config.PreTreasure].state == TreasureState.Collected)
|
{
|
switch ((TreasureCategory)config.Category)
|
{
|
case TreasureCategory.Human:
|
case TreasureCategory.Demon:
|
if (treasure.state == TreasureState.Locked)
|
{
|
int _unlockAchievement = 0;
|
Achievement _achievement;
|
treasureAchievementDict.TryGetValue(treasure.id, out _unlockAchievement);
|
achievementModel.TryGetAchievement(_unlockAchievement, out _achievement);
|
if (_achievement == null || _achievement.completed)
|
{
|
if (serverInited)
|
{
|
SetTreasureUnlockShow((TreasureCategory)config.Category, treasure.id);
|
}
|
treasure.state = TreasureState.Collecting;
|
UpdateDemonDungeonRedpoint(treasure.id);
|
if ((TreasureCategory)config.Category == TreasureCategory.Human)
|
{
|
(treasure as HumanTreasure).UpdateTreasureState();
|
}
|
if ((TreasureCategory)config.Category == TreasureCategory.Demon)
|
{
|
collectingDemon = key;
|
}
|
else if ((TreasureCategory)config.Category == TreasureCategory.Human)
|
{
|
collectingHuman = key;
|
}
|
}
|
}
|
break;
|
default:
|
break;
|
}
|
|
if (treasureStateChangeEvent != null)
|
{
|
treasureStateChangeEvent(key);
|
}
|
}
|
}
|
|
UpdateStoveRedpoint();
|
UpdateSkillLevelUpRedpoints();
|
}
|
|
public void UpdateTreasurePotentialInfo(int _oldSkillId, int _newSkillId)
|
{
|
var config = SkillConfig.Get(_newSkillId);
|
foreach (var key in treasures.Keys)
|
{
|
var treasure = treasures[key];
|
if (treasure.GetPotential(config.SkillTypeID) != null)
|
{
|
treasure.UpdatePotentialLevel(config.SkillTypeID, config.SkillLV);
|
if (treasure is HumanTreasure)
|
{
|
(treasure as HumanTreasure).UpdateTreasureState();
|
}
|
if (potentialLevelUpdate != null)
|
{
|
potentialLevelUpdate(config.SkillTypeID, config.SkillLV);
|
}
|
if (potentialLevelChangeEvent != null)
|
{
|
potentialLevelChangeEvent(key, config.SkillTypeID);
|
}
|
UpdateSkillLevelUpRedpoints();
|
break;
|
}
|
}
|
|
}
|
|
private void OnAchievementProgressUpdate(int _achievement)
|
{
|
foreach (var treasure in treasures.Values)
|
{
|
int[] achievements = null;
|
var config = TreasureConfig.Get(treasure.id);
|
if ((TreasureCategory)config.Category == TreasureCategory.Human)
|
{
|
achievements = treasure.achievements.ToArray();
|
}
|
else
|
{
|
achievements = config.Achievements;
|
}
|
if (achievements == null)
|
{
|
return;
|
}
|
if (Array.IndexOf(achievements, _achievement) != -1)
|
{
|
UpdateTreasureCollectProgress(treasure);
|
}
|
}
|
|
if (eightFurnacesAchievements.Contains(_achievement))
|
{
|
UpdateStoveRedpoint();
|
}
|
}
|
|
private void UpdateTreasureCollectProgress(Treasure _treasure)
|
{
|
var config = TreasureConfig.Get(_treasure.id);
|
var oldProgress = _treasure.progress;
|
var tempProgress = 0;
|
Achievement achievement;
|
//if (achievementModel.TryGetAchievement(config.MainID, out achievement))
|
//{
|
// if (achievement.completed)
|
// {
|
// tempProgress++;
|
// }
|
//}
|
|
int[] achievements = config.Achievements;
|
if ((TreasureCategory)config.Category == TreasureCategory.Human)
|
{
|
achievements = _treasure.achievements.ToArray();
|
}
|
else
|
{
|
achievements = config.Achievements;
|
}
|
|
for (int i = 0; i < achievements.Length; i++)
|
{
|
if (achievementModel.TryGetAchievement(achievements[i], out achievement))
|
{
|
if (achievement.completed)
|
{
|
tempProgress++;
|
}
|
}
|
}
|
|
if (oldProgress != tempProgress)
|
{
|
_treasure.progress = tempProgress;
|
if (treasureCollectProgressUpdateEvent != null)
|
{
|
treasureCollectProgressUpdateEvent(_treasure.id);
|
}
|
}
|
}
|
|
private void OnGetSkillLevelUpResult(H0721_tagMakeItemAnswer _result)
|
{
|
switch ((MakeType)_result.MakeType)
|
{
|
case MakeType.Def_treasureSkillEquip:
|
if (onPotentialLevelUpResultEvent != null)
|
{
|
onPotentialLevelUpResultEvent(levelUpTreasureIdBuf, levelUpPotentialBuf, _result.Result == 1);
|
}
|
|
levelUpTreasureIdBuf = 0;
|
levelUpPotentialBuf = 0;
|
break;
|
}
|
}
|
|
private void OnTreasurePotentialSPChange(PlayerDataRefresh refreshType)
|
{
|
switch (refreshType)
|
{
|
case PlayerDataRefresh.ExAttr7:
|
case PlayerDataRefresh.ExAttr8:
|
UpdateSkillLevelUpRedpoints();
|
break;
|
case PlayerDataRefresh.LV:
|
playerLevelRefresh = true;
|
break;
|
case PlayerDataRefresh.FightPoint:
|
case PlayerDataRefresh.FightPower:
|
UpdateDemonDungeonRedpoints();
|
break;
|
}
|
}
|
|
private void OnPackageItemChange(PackType _type, int _index, int _itemId)
|
{
|
if (_type == PackType.Item)
|
{
|
var config = ItemConfig.Get(_itemId);
|
if (config.Type == 6)
|
{
|
UpdateSkillLevelUpRedpoints();
|
}
|
}
|
}
|
|
private void OnFunctionStateChange(int _functionId)
|
{
|
if (_functionId == 82)
|
{
|
UpdateSkillLevelUpRedpoints();
|
bool requireCheckUnlockShow = false;
|
if (!potentialFuncOpen && FuncOpen.Instance.IsFuncOpen(82))
|
{
|
requireCheckUnlockShow = true;
|
}
|
potentialFuncOpen = FuncOpen.Instance.IsFuncOpen(82);
|
var list = treasureCategory[TreasureCategory.Human];
|
for (int i = 0; i < list.Count; i++)
|
{
|
Treasure treasure;
|
TryGetTreasure(list[i], out treasure);
|
var humanTreasure = treasure as HumanTreasure;
|
humanTreasure.UpdateTreasureState();
|
if (!serverInited || !treasure.IsHighestStage || !requireCheckUnlockShow)
|
{
|
continue;
|
}
|
if (IsPotentialUnlock(list[i], treasure.potentials[0].id))
|
{
|
SetPotentialUnlockShow(list[i], true);
|
}
|
}
|
}
|
}
|
|
private void UpdateSkillLevelUpRedpoints()
|
{
|
var list = GetTreasureCategory(TreasureCategory.Human);
|
for (int i = 0; i < list.Count; i++)
|
{
|
var id = list[i];
|
if (treasures[id].skillLevelUpRedpoint != null)
|
{
|
treasures[id].skillLevelUpRedpoint.state = RedPointState.None;
|
}
|
}
|
var functionOpen = FuncOpen.Instance.IsFuncOpen(82);
|
if (functionOpen)
|
{
|
for (int k = 0; k < 3; k++)
|
{
|
for (int i = 0; i < list.Count; i++)
|
{
|
var treasure = treasures[list[i]];
|
if (k < treasure.potentials.Count)
|
{
|
var potential = treasure.potentials[k];
|
Item item;
|
if (SatisfyLevelUpUnlock(list[i], k)
|
&& SatisyPotentialLevelUp(list[i], potential.id, out item))
|
{
|
treasure.skillLevelUpRedpoint.state = RedPointState.Simple;
|
treasure.autoSelectPotential = k;
|
if (skillLevelUpRedpointUpdate != null)
|
{
|
skillLevelUpRedpointUpdate();
|
}
|
return;
|
}
|
}
|
}
|
}
|
int minCostTreasure = 0;
|
int minCostPotentialIndex = 0;
|
int minCostItemColor = 0;
|
int minCostItemCount = 0;
|
bool step = false;
|
for (int i = 0; i < list.Count; i++)
|
{
|
var treasure = treasures[list[i]];
|
if (treasure.state != TreasureState.Collected || !treasure.IsHighestStage)
|
{
|
continue;
|
}
|
for (int k = 0; k < treasure.potentials.Count; k++)
|
{
|
Item item;
|
if (SatisyPotentialLevelUp(treasure.id, treasure.potentials[k].id, out item))
|
{
|
if (item.id != 0)
|
{
|
var itemConfig = ItemConfig.Get(item.id);
|
var itemColor = itemConfig.ItemColor;
|
if (minCostItemColor == 0 || itemColor < minCostItemColor ||
|
(itemColor == minCostItemColor && item.count < minCostItemCount))
|
{
|
minCostItemColor = itemColor;
|
minCostItemCount = item.count;
|
minCostTreasure = treasure.id;
|
minCostPotentialIndex = k;
|
}
|
}
|
else
|
{
|
minCostTreasure = treasure.id;
|
minCostPotentialIndex = k;
|
step = true;
|
break;
|
}
|
}
|
}
|
if (step)
|
{
|
break;
|
}
|
}
|
if (minCostTreasure != 0)
|
{
|
treasures[minCostTreasure].skillLevelUpRedpoint.state = RedPointState.Simple;
|
treasures[minCostTreasure].autoSelectPotential = minCostPotentialIndex;
|
}
|
}
|
if (skillLevelUpRedpointUpdate != null)
|
{
|
skillLevelUpRedpointUpdate();
|
}
|
}
|
|
private void UpdateDemonDungeonRedpoints()
|
{
|
foreach (var treasureId in treasureDungeons.Keys)
|
{
|
UpdateDemonDungeonRedpoint(treasureId);
|
}
|
}
|
|
private void UpdateDemonDungeonRedpoint(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 >= dungeonInfo.fightPower)
|
{
|
treasureDungeon.challengeRedpoint.state = RedPointState.Simple;
|
}
|
}
|
}
|
}
|
|
public int GetSkillLevelUpRedpointTreasure()
|
{
|
var list = GetTreasureCategory(TreasureCategory.Human);
|
for (int i = 0; i < list.Count; i++)
|
{
|
var treasure = treasures[list[i]];
|
if (treasure.skillLevelUpRedpoint != null &&
|
treasure.skillLevelUpRedpoint.state == RedPointState.Simple)
|
{
|
return list[i];
|
}
|
}
|
return 0;
|
}
|
|
private void UpdateAchievementRedpoints()
|
{
|
foreach (var id in treasures.Keys)
|
{
|
UpdateAchievementRedpoint(id);
|
}
|
}
|
|
private void UpdateCastSoulRedpoints()
|
{
|
foreach (var id in treasures.Keys)
|
{
|
UpdateCastSoulRedpoint(id);
|
}
|
}
|
|
private void UpdateStoveRedpoint()
|
{
|
Treasure treasure;
|
if (TryGetTreasure(301, out treasure))
|
{
|
stoveRedpoint.state = RedPointState.None;
|
return;
|
}
|
}
|
|
public bool TreasureStageUpLimit(int _treasureId, bool _tip = true)
|
{
|
if (PlayerDatas.Instance.baseData.LV >= treasureExitLvLimit)
|
{
|
return false;
|
}
|
Treasure _treasure;
|
if (TryGetTreasure(_treasureId, out _treasure))
|
{
|
var human = _treasure as HumanTreasure;
|
if (human != null && human.castSoulRedpoint.state == RedPointState.Simple)
|
{
|
if (_tip)
|
{
|
SysNotifyMgr.Instance.ShowTip("FabaoAwaken");
|
}
|
return true;
|
}
|
}
|
return false;
|
}
|
|
private void OnWindowOpen(Window _window)
|
{
|
if (_window is MainInterfaceWin)
|
{
|
SnxxzGame.Instance.StartCoroutine(Co_OpenTreasureNewGot());
|
if (needDisplayReguluLevelUp)
|
{
|
CheckReguluPop();
|
}
|
}
|
}
|
|
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());
|
}
|
}
|
|
IEnumerator Co_OpenTreasureNewGot()
|
{
|
yield return null;
|
OpenTreasureNewGot();
|
}
|
|
public void CheckOpenTreasureNewGot()
|
{
|
SnxxzGame.Instance.StartCoroutine(Co_OpenTreasureNewGot());
|
}
|
|
private void OpenTreasureNewGot()
|
{
|
if (!(StageLoad.Instance.currentStage is DungeonStage) || !serverInited)
|
{
|
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>();
|
}
|
|
public bool SatisfyLevelUpUnlock(int treasureId, int index)
|
{
|
if (treasures.ContainsKey(treasureId))
|
{
|
var treasure = treasures[treasureId];
|
if (treasure.state == TreasureState.Collected && treasure.IsHighestStage)
|
{
|
if (index >= 0 && index < treasure.potentials.Count - 1)
|
{
|
var potential = treasure.potentials[index];
|
var nextPotential = treasure.potentials[index + 1];
|
var skillConfig = SkillConfig.Get(nextPotential.id);
|
if (skillConfig.LearnSkillReq > 0)
|
{
|
if (potential.level < skillConfig.LearnSkillLV)
|
{
|
return true;
|
}
|
}
|
}
|
else if (index == treasure.potentials.Count - 1)
|
{
|
var potential = treasure.GetPotentialByIndex(index);
|
var config = SkillConfig.Get(potential.id);
|
int[] _getSkillArray;
|
if (TryGetPotentialGetSkill(config.SkillTypeID, out _getSkillArray))
|
{
|
if (potential.level < _getSkillArray[0])
|
{
|
return true;
|
}
|
}
|
}
|
}
|
}
|
return false;
|
}
|
|
public bool SatisyPotentialLevelUp(int treasureId, int potentialId, out Item item)
|
{
|
item = default(Item);
|
var treasure = treasures[treasureId];
|
var potential = treasure.GetPotential(potentialId);
|
if (potential == null)
|
{
|
return false;
|
}
|
var config = SkillConfig.Get(potential.id);
|
if (potential.level >= config.SkillMaxLV)
|
{
|
return false;
|
}
|
|
if (config.LearnSkillReq > 0)
|
{
|
var preSkillLevelRequirement = config.LearnSkillLV;
|
var preSkill = PlayerDatas.Instance.skill.GetSkillBySkillTypeID(config.LearnSkillReq);
|
var preSkillLevel = preSkill == null ? 0 : preSkill.level;
|
|
if (preSkillLevel < preSkillLevelRequirement)
|
{
|
return false;
|
}
|
}
|
|
if (PlayerDatas.Instance.baseData.LV < config.LearnLVReq)
|
{
|
return false;
|
}
|
|
var levelUpType = GetSkillLevelUpType(potential.id);
|
var levelupId = GetSkillLevelUpId(levelUpType, potential.level + 1);
|
var treasureSkillConfig = TreasureSkillConfig.Get(levelupId);
|
var spOwn = PlayerDatas.Instance.baseData.treasurePotentialSp;
|
var spNeed = treasureSkillConfig.MeterialNum1;
|
|
if (spOwn < spNeed)
|
{
|
return false;
|
}
|
|
if (treasureSkillConfig.InitialRate >= 8000)
|
{
|
return true;
|
}
|
else
|
{
|
for (int j = 0; j < treasureSkillConfig.MeterialNum2.Length; j++)
|
{
|
var rate = treasureSkillConfig.Rate[j];
|
if (rate >= 6000)
|
{
|
var itemId = treasureSkillConfig.Meterial2ID[j];
|
var own = packageModel.GetItemCountByID(PackType.Item, itemId);
|
if (own >= treasureSkillConfig.MeterialNum2[j])
|
{
|
item = new Item()
|
{
|
id = itemId,
|
count = treasureSkillConfig.MeterialNum2[j],
|
};
|
return true;
|
}
|
}
|
}
|
}
|
return false;
|
}
|
|
private void OnAchievementAwardable(int _achievementId)
|
{
|
foreach (var treasure in treasures.Values)
|
{
|
if (treasure.achievements.Contains(_achievementId))
|
{
|
UpdateAchievementRedpoint(treasure.id);
|
}
|
|
}
|
}
|
|
private void OnAchievementCompleted(int _achievementId)
|
{
|
foreach (var treasure in treasures.Values)
|
{
|
if (treasure.achievements.Contains(_achievementId))
|
{
|
UpdateAchievementRedpoint(treasure.id);
|
}
|
|
var config = TreasureConfig.Get(treasure.id);
|
if (treasure.achievements.Contains(_achievementId))
|
{
|
UpdateTreasureCollectProgress(treasure);
|
}
|
|
if (treasure.state == TreasureState.Locked)
|
{
|
Achievement achievement = null;
|
int _lockAchievement = 0;
|
if (TryGetTreasureUnlockAchievement(treasure.id, out _lockAchievement))
|
{
|
if (achievementModel.TryGetAchievement(_lockAchievement, out achievement)
|
&& achievement.completed)
|
{
|
Treasure _pretreasure;
|
switch ((TreasureCategory)config.Category)
|
{
|
case TreasureCategory.Human:
|
TryGetTreasure(config.PreTreasure, out _pretreasure);
|
if (_pretreasure == null || _pretreasure.state == TreasureState.Collected)
|
{
|
treasure.state = TreasureState.Collecting;
|
(treasure as HumanTreasure).UpdateTreasureState();
|
collectingHuman = treasure.id;
|
if (serverInited)
|
{
|
SetTreasureUnlockShow((TreasureCategory)config.Category, config.ID);
|
}
|
}
|
break;
|
case TreasureCategory.Demon:
|
TryGetTreasure(config.PreTreasure, out _pretreasure);
|
if (_pretreasure == null || _pretreasure.state == TreasureState.Collected)
|
{
|
treasure.state = TreasureState.Collecting;
|
UpdateDemonDungeonRedpoint(treasure.id);
|
collectingDemon = treasure.id;
|
if (serverInited)
|
{
|
SetTreasureUnlockShow((TreasureCategory)config.Category, config.ID);
|
}
|
}
|
break;
|
case TreasureCategory.Fairy:
|
break;
|
}
|
|
if (treasureStateChangeEvent != null)
|
{
|
treasureStateChangeEvent(treasure.id);
|
}
|
}
|
}
|
}
|
}
|
|
if (eightFurnacesAchievements.Contains(_achievementId))
|
{
|
UpdateStoveRedpoint();
|
}
|
}
|
|
private void UpdateAchievementRedpoint(int _treasureId)
|
{
|
if (!treasures.ContainsKey(_treasureId))
|
{
|
return;
|
}
|
|
var treasure = treasures[_treasureId];
|
var config = TreasureConfig.Get(_treasureId);
|
treasure.achievementRedpoint.state = RedPointState.None;
|
if ((TreasureCategory)config.Category == TreasureCategory.Human && treasure.state != TreasureState.Collected)
|
{
|
return;
|
}
|
|
if ((TreasureCategory)config.Category == TreasureCategory.Demon && !FuncOpen.Instance.IsFuncOpen(107))
|
{
|
return;
|
}
|
|
if((TreasureCategory)config.Category == TreasureCategory.Human && treasure.IsHighestStage)
|
{
|
return;
|
}
|
|
foreach (var achievementGroup in treasure.achievementGroups.Values)
|
{
|
if (achievementGroup.IsAwardable())
|
{
|
treasure.achievementRedpoint.state = RedPointState.Simple;
|
break;
|
}
|
|
treasure.achievementRedpoint.state = RedPointState.None;
|
}
|
|
}
|
|
private void UpdateCastSoulRedpoint(int _treasureId)
|
{
|
if (!treasures.ContainsKey(_treasureId))
|
{
|
return;
|
}
|
|
var treasure = treasures[_treasureId] as HumanTreasure;
|
if (treasure == null)
|
{
|
return;
|
}
|
treasure.castSoulRedpoint.state = RedPointState.None;
|
if (treasure.state != TreasureState.Collected ||
|
treasure.humanState != HumanTreasureState.CastSoul)
|
{
|
return;
|
}
|
|
var _nextStage = treasure.treasureStages.Find((x) =>
|
{
|
return x.stage == treasure.stage + 1;
|
});
|
if (_nextStage != null)
|
{
|
if (treasure.exp >= _nextStage.exp)
|
{
|
treasure.castSoulRedpoint.state = RedPointState.Simple;
|
}
|
}
|
}
|
|
public void UpdateTreasureLevelInfo(HA352_tagMCMagicWeaponLVInfo package)
|
{
|
for (int i = 0; i < package.Count; i++)
|
{
|
Treasure treasure;
|
if (TryGetTreasure((int)package.InfoList[i].MWID, out treasure))
|
{
|
bool _up = false;
|
if (treasure.stage < package.InfoList[i].LV)
|
{
|
_up = true;
|
}
|
treasure.UpdateTreasureLevelExp(package.InfoList[i].LV, (int)package.InfoList[i].Exp, package.InfoList[i].State == 1);
|
if (serverInited && treasure.IsHighestStage)
|
{
|
SetTreasureFinishAnim(treasure.id);
|
}
|
if (treasureLevelProgressUpdateEvent != null)
|
{
|
treasureLevelProgressUpdateEvent(treasure.id);
|
}
|
UpdateCastSoulRedpoint(treasure.id);
|
UpdateAchievementRedpoint(treasure.id);
|
if (serverInited && _up && treasureStageUpEvent != null)
|
{
|
treasureStageUpEvent(treasure.id);
|
}
|
}
|
TreasureDungeon treasureDungeon;
|
if (TryGetTreasureDungeon((int)package.InfoList[i].MWID, out treasureDungeon))
|
{
|
treasureDungeon.currentLevel = package.InfoList[i].FBPassLV;
|
UpdateDemonDungeonRedpoint(treasureDungeon.treasureId);
|
if (demonTreasureDungeonUpdate != null)
|
{
|
demonTreasureDungeonUpdate(treasureDungeon.treasureId);
|
}
|
}
|
}
|
UpdateSkillLevelUpRedpoints();
|
}
|
|
public void HumanTreasureStateChange(int _id)
|
{
|
if (humanTreasureStateChangeEvent != null)
|
{
|
humanTreasureStateChangeEvent(_id);
|
}
|
}
|
|
public List<int> GetFurnacesAchievements()
|
{
|
return eightFurnacesAchievements;
|
}
|
|
public bool IsVersionUnOpenTreasure(int _id)
|
{
|
return treasureUnOpens.Contains(_id);
|
}
|
|
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);
|
var skillLevelUpRedpoint = config.Potentials.Length > 0 ? new Redpoint(CATEGORY_REDPOINTIDS[config.Category - 1], TREASURE_REDPOINTBASE + redpointIndex++) : null;
|
var achievementRedpoint = new Redpoint(CATEGORY_REDPOINTIDS[config.Category - 1], TREASURE_REDPOINTBASE + redpointIndex++);
|
Treasure treasure;
|
if (category == TreasureCategory.Human)
|
{
|
var caseSoulRedpoint = new Redpoint(CATEGORY_REDPOINTIDS[config.Category - 1], TREASURE_REDPOINTBASE + redpointIndex++);
|
treasure = new HumanTreasure(config.ID, config.Potentials, skillLevelUpRedpoint, achievementRedpoint, caseSoulRedpoint);
|
potentialInitialPowers.Add(config.ID, config.SkillPower);
|
}
|
else
|
{
|
treasure = new Treasure(config.ID, config.Potentials, skillLevelUpRedpoint, achievementRedpoint);
|
}
|
|
treasures[config.ID] = treasure;
|
|
for (int i = 0; i < config.Achievements.Length; i++)
|
{
|
var achieveConfig = SuccessConfig.Get(config.Achievements[i]);
|
if (achieveConfig == null)
|
{
|
continue;
|
}
|
if (config.Category == (int)TreasureCategory.Human
|
&& (achieveConfig.Type == 3 || achieveConfig.Type == 1))
|
{
|
treasureAchievementDict.Add(config.ID, config.Achievements[i]);
|
break;
|
}
|
else if (config.Category == (int)TreasureCategory.Demon
|
&& (achieveConfig.Type == 3 || achieveConfig.Type == 1))
|
{
|
treasureAchievementDict.Add(config.ID, config.Achievements[i]);
|
break;
|
}
|
//else if (config.Category == (int)TreasureCategory.Fairy && config.ID == 301)
|
//{
|
// eightFurnacesAchievements.Add(config.Achievements[i]);
|
//}
|
}
|
|
if (treasure.state == TreasureState.Locked && config.PreTreasure == 0)
|
{
|
treasure.state = TreasureState.Collecting;
|
switch ((TreasureCategory)config.Category)
|
{
|
case TreasureCategory.Human:
|
collectingHuman = treasure.id;
|
break;
|
case TreasureCategory.Demon:
|
collectingDemon = treasure.id;
|
break;
|
}
|
}
|
|
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.ParseTreasureStage(config);
|
}
|
}
|
|
var funcConfig = FuncConfigConfig.Get("GuideMission");
|
castSoulGuideTaskIds = new List<int>();
|
castSoulGuideTaskIds.AddRange(ConfigParse.GetMultipleStr<int>(funcConfig.Numerical1));
|
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);
|
treasureBackPercent = float.Parse(funcConfig.Numerical2);
|
funcConfig = FuncConfigConfig.Get("TreasureExitLimit");
|
treasureExitLvLimit = int.Parse(funcConfig.Numerical1);
|
|
funcConfig = FuncConfigConfig.Get("TreasureNoOpen");
|
treasureUnOpens.AddRange(ConfigParse.GetMultipleStr<int>(funcConfig.Numerical1));
|
|
funcConfig = FuncConfigConfig.Get("OpenFabao");
|
entranceOpenCondition = int.Parse(funcConfig.Numerical1);
|
|
stoveRedpoint = new Redpoint(CATEGORY_REDPOINTIDS[(int)TreasureCategory.Fairy - 1], TREASURE_REDPOINTBASE + redpointIndex++);
|
|
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);
|
}
|
|
funcConfig = FuncConfigConfig.Get("TreasureSpTarget");
|
potentialNextTargetLevels.AddRange(ConfigParse.GetMultipleStr<int>(funcConfig.Numerical1));
|
}
|
|
const string pattern = "\\\"[0-9]+\\\":\\[[0-9|,]*\\]";
|
private void ParseSkillLevelUpConfig()
|
{
|
try
|
{
|
var config = FuncConfigConfig.Get("SPSkillType");
|
var matches = Regex.Matches(config.Numerical1, pattern);
|
|
for (int i = 0; i < matches.Count; i++)
|
{
|
var match = matches[i].Value;
|
var stringArray = match.Split(':');
|
|
var key = 0;
|
int.TryParse(Regex.Match(stringArray[0], "[0-9]+").Value, out key);
|
var skillList = skillLevelUpTypes[key] = new List<int>();
|
var skillMatches = Regex.Matches(stringArray[1], "[0-9]{2,}");
|
for (int j = 0; j < skillMatches.Count; j++)
|
{
|
skillList.Add(int.Parse(skillMatches[j].Value));
|
}
|
}
|
}
|
catch (Exception ex)
|
{
|
DebugEx.Log(ex);
|
}
|
|
}
|
|
public static int GetSkillLevelUpId(int _type, int _level)
|
{
|
return _type * 100 + _level;
|
}
|
|
public int GetMapIdByTreasure(int _treasureId)
|
{
|
if (treasureMapDict.ContainsKey(_treasureId))
|
{
|
return treasureMapDict[_treasureId];
|
}
|
return 0;
|
}
|
|
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.stage < _stage.stage)
|
{
|
break;
|
}
|
_fightPower += _stage.GetFightPower();
|
_fightPower += _stage.powerEx;
|
}
|
_fightPower += GetExtensionPower(_treasureId);
|
return _fightPower;
|
}
|
|
public int GetExtensionPower(int _treasureId)
|
{
|
var treasureSoulModel = ModelCenter.Instance.GetModel<TreasureSoulModel>();
|
if (_treasureId == treasureSoulModel.signAddTreasure)
|
{
|
var signInDays = ModelCenter.Instance.GetModel<SignInModel>().totalSignInCount;
|
if (signInDays == 0)
|
{
|
return 0;
|
}
|
Dictionary<int, int> dict = new Dictionary<int, int>();
|
foreach (var key in treasureSoulModel.signAddProperty.Keys)
|
{
|
dict.Add(key, treasureSoulModel.signAddProperty[key] * signInDays);
|
}
|
return UIHelper.GetFightPower(dict);
|
}
|
return 0;
|
}
|
|
Dictionary<int, int[]> m_TreasurePotentialGetSkills = new Dictionary<int, int[]>();
|
private void ParsePotentialSkillConfig()
|
{
|
var _cfg = FuncConfigConfig.Get("PotentialSkillLearn");
|
var _jsonData = LitJson.JsonMapper.ToObject(_cfg.Numerical1);
|
foreach (var _key in _jsonData.Keys)
|
{
|
var _typeId = int.Parse(_key);
|
m_TreasurePotentialGetSkills.Add(_typeId, LitJson.JsonMapper.ToObject<int[]>(_jsonData[_key].ToJson()));
|
}
|
}
|
|
public bool TryGetPotentialGetSkill(int _skillTypeId, out int[] _array)
|
{
|
return m_TreasurePotentialGetSkills.TryGetValue(_skillTypeId, out _array);
|
}
|
|
public bool IsPotentialUnlock(int treasureId, int potentialId)
|
{
|
if (!FuncOpen.Instance.IsFuncOpen(82))
|
{
|
return false;
|
}
|
Treasure treasure;
|
if (TryGetTreasure(treasureId, out treasure))
|
{
|
var potential = treasure.GetPotential(potentialId);
|
if (potential != null)
|
{
|
var skillConfig = SkillConfig.Get(potential.id);
|
if (skillConfig.LearnSkillReq > 0)
|
{
|
var prepotential = treasure.GetPotential(skillConfig.LearnSkillReq);
|
if (prepotential != null && prepotential.level < skillConfig.LearnSkillLV)
|
{
|
return false;
|
}
|
}
|
}
|
}
|
return true;
|
}
|
|
public int GetPotentialInitialPower(int treasureId, int index)
|
{
|
if (potentialInitialPowers.ContainsKey(treasureId))
|
{
|
var powerArray = potentialInitialPowers[treasureId];
|
if (powerArray != null && index < powerArray.Length && index >= 0)
|
{
|
return powerArray[index];
|
}
|
}
|
return 0;
|
}
|
|
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 int GetPotentialNextTargetLevel(int level)
|
{
|
var list = potentialNextTargetLevels;
|
for (int i = 0; i < list.Count; i++)
|
{
|
if (level < list[i])
|
{
|
if (level < list[i] - 1)
|
{
|
return list[i];
|
}
|
break;
|
}
|
}
|
return 0;
|
}
|
|
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 int GetTreasureBySkillId(int skillId)
|
{
|
var list = GetTreasureCategory(TreasureCategory.Human);
|
for (int i = 0; i < list.Count; i++)
|
{
|
Treasure treasure;
|
if (TryGetTreasure(list[i], out treasure)
|
&& treasure.unlockSkill == skillId)
|
{
|
return list[i];
|
}
|
}
|
return 0;
|
}
|
}
|
|
}
|
|
|
|
