//--------------------------------------------------------
|
// [Author]: 第二世界
|
// [ Date ]: Monday, October 09, 2017
|
//--------------------------------------------------------
|
using UnityEngine;
|
using System.Collections;
|
using System.Collections.Generic;
|
using UnityEngine.UI;
|
using TableConfig;
|
using System;
|
using System.Text.RegularExpressions;
|
|
namespace Snxxz.UI
|
{
|
|
public class Treasure
|
{
|
public int id { get; private set; }
|
|
int m_Stage;
|
public int stage
|
{
|
get { return m_Stage; }
|
private set { m_Stage = value; }
|
}
|
|
int m_Exp;
|
public int exp
|
{
|
get { return m_Exp; }
|
private set { m_Exp = value; }
|
}
|
|
bool m_HasClickChallenge = false;
|
public bool hasClickChallenge
|
{
|
get { return m_HasClickChallenge; }
|
set { m_HasClickChallenge = value; }
|
}
|
|
TreasureState m_State = TreasureState.Locked;
|
public TreasureState state
|
{
|
get { return m_State; }
|
set { m_State = value; }
|
}
|
|
int m_Progress = 0;
|
public int progress
|
{
|
get { return m_Progress; }
|
set { m_Progress = value; }
|
}
|
|
public bool isChallengeDungeonAble
|
{
|
get
|
{
|
if (state != TreasureState.Collecting)
|
{
|
return false;
|
}
|
var config = Config.Instance.Get<TreasureConfig>(id);
|
return progress >= config.RequirementTotal;// && config.LastSuccID > 0;
|
}
|
}
|
|
public int unLockSkill
|
{
|
get
|
{
|
var job = PlayerDatas.Instance.baseData.Job;
|
var stage = treasureStages.Find((x) =>
|
{
|
return x.unlockType == TreasureStageUnlock.Skill;
|
});
|
return stage != null ? stage.GetSkill(job) : 0;
|
}
|
}
|
|
public int unLockPrivilege
|
{
|
get; private set;
|
}
|
|
public int autoSelectPotential { get; set; }
|
|
Dictionary<int, List<TreasurePotential>> jobToPotentials = new Dictionary<int, List<TreasurePotential>>();
|
|
public List<TreasurePotential> potentials
|
{
|
get
|
{
|
if (jobToPotentials.ContainsKey(PlayerDatas.Instance.baseData.Job))
|
{
|
return jobToPotentials[PlayerDatas.Instance.baseData.Job];
|
}
|
else
|
{
|
return null;
|
}
|
}
|
}
|
|
public List<int> achievements = new List<int>();
|
public Dictionary<int, AchievementGroup> achievementGroups = new Dictionary<int, AchievementGroup>();
|
|
public Redpoint skillLevelUpRedpoint { get; private set; }
|
public Redpoint achievementRedpoint { get; private set; }
|
|
public Treasure(int _id)
|
{
|
this.id = _id;
|
}
|
|
public Treasure(int _id, int[] _potentialIds, Redpoint _skillLevelUpRedpoint, Redpoint _achievementPoint)
|
{
|
this.id = _id;
|
this.skillLevelUpRedpoint = _skillLevelUpRedpoint;
|
this.achievementRedpoint = _achievementPoint;
|
|
var config = Config.Instance.Get<TreasureConfig>(this.id);
|
List<int> _expAchievements;
|
if (SuccessConfig.TryGetTreasureExpAchievements(_id, out _expAchievements))
|
{
|
achievements.AddRange(_expAchievements);
|
}
|
|
foreach (var achievement in achievements)
|
{
|
var achievementConfig = Config.Instance.Get<SuccessConfig>(achievement);
|
|
AchievementGroup group;
|
if (achievementGroups.ContainsKey(achievementConfig.Group))
|
{
|
group = achievementGroups[achievementConfig.Group];
|
}
|
else
|
{
|
achievementGroups[achievementConfig.Group] = group = new AchievementGroup(achievementConfig.Group);
|
}
|
|
group.AddAchievement(achievement);
|
}
|
|
foreach (var group in achievementGroups.Values)
|
{
|
group.Sort();
|
}
|
|
for (int i = 0; i < _potentialIds.Length; i++)
|
{
|
var skillId = _potentialIds[i];
|
var skillConfig = Config.Instance.Get<SkillConfig>(skillId);
|
if (skillConfig == null)
|
{
|
continue;
|
}
|
|
for (int j = 0; j < GeneralDefine.openJobs.Length; j++)
|
{
|
var job = GeneralDefine.openJobs[j];
|
List<TreasurePotential> tempPotentials;
|
if (jobToPotentials.ContainsKey(job))
|
{
|
tempPotentials = jobToPotentials[job];
|
}
|
else
|
{
|
jobToPotentials[job] = tempPotentials = new List<TreasurePotential>();
|
}
|
|
if (skillConfig.UseType == 0 || skillConfig.UseType == 1 << job)
|
{
|
tempPotentials.Add(new TreasurePotential(skillId, 0));
|
}
|
}
|
}
|
}
|
|
public TreasurePotential GetPotential(int _potentialId)
|
{
|
if (potentials == null)
|
{
|
return null;
|
}
|
else
|
{
|
for (int i = 0; i < potentials.Count; i++)
|
{
|
var potential = potentials[i];
|
if (potential.id == _potentialId)
|
{
|
return potential;
|
}
|
}
|
|
return null;
|
}
|
}
|
|
public TreasurePotential GetPotentialByIndex(int index)
|
{
|
if (potentials == null)
|
{
|
return null;
|
}
|
else
|
{
|
if (index >= 0 && index < potentials.Count)
|
{
|
return potentials[index];
|
}
|
|
return null;
|
}
|
}
|
|
public void UpdatePotentialLevel(int _potentialId, int _level)
|
{
|
for (int i = 0; i < potentials.Count; i++)
|
{
|
var potential = potentials[i];
|
if (potential.id == _potentialId)
|
{
|
potential.level = _level;
|
break;
|
}
|
}
|
}
|
|
public AchievementGroup FindAchievementGroup(int _achievementId)
|
{
|
foreach (var key in achievementGroups.Keys)
|
{
|
var achievementGroup = achievementGroups[key];
|
if (achievementGroup.Contain(_achievementId))
|
{
|
return achievementGroup;
|
}
|
}
|
|
return null;
|
}
|
|
private int AchievementCompare(int _lhs, int _rhs)
|
{
|
var configA = Config.Instance.Get<SuccessConfig>(_lhs);
|
var configB = Config.Instance.Get<SuccessConfig>(_rhs);
|
|
return configA.ReOrder < configB.ReOrder ? -1 : 1;
|
}
|
|
public List<TreasureStage> treasureStages = new List<TreasureStage>();
|
public void UpdateTreasureStage(TreasureUpConfig _cfg)
|
{
|
TreasureStage _stage = new TreasureStage(_cfg);
|
treasureStages.Add(_stage);
|
}
|
|
|
|
public void UpdateTreasureLevelExp(int _lv, int _exp, bool _hasClickChallenge)
|
{
|
stage = _lv;
|
exp = _exp;
|
hasClickChallenge = _hasClickChallenge;
|
if ((this is HumanTreasure))
|
{
|
(this as HumanTreasure).UpdateTreasureState();
|
}
|
}
|
|
public bool IsHighestStage
|
{
|
get
|
{
|
return treasureStages.FindIndex((x) =>
|
{
|
return x.stage >= stage + 1;
|
}) == -1;
|
}
|
}
|
|
public bool IsUnlockStage(TreasureStageUnlock _type)
|
{
|
var _stage = treasureStages.Find((x) =>
|
{
|
return x.unlockType == _type;
|
});
|
if (_stage == null)
|
{
|
return false;
|
}
|
return stage >= _stage.stage;
|
}
|
|
public int GetStageId(int _stageIndex)
|
{
|
foreach (var item in treasureStages)
|
{
|
if (item.stage == _stageIndex)
|
{
|
return item.id;
|
}
|
}
|
|
return 0;
|
}
|
|
public int GetStageIndex(int _stage)
|
{
|
if (treasureStages[0].unlockType == TreasureStageUnlock.None)
|
{
|
return Mathf.Max(_stage - 1, 0);
|
}
|
return _stage;
|
}
|
|
public int StageCount
|
{
|
get { return treasureStages.Count; }
|
}
|
}
|
|
public class HumanTreasure : Treasure
|
{
|
HumanTreasureState m_State = HumanTreasureState.Locked;
|
public HumanTreasureState humanState
|
{
|
get
|
{
|
return m_State;
|
}
|
private set
|
{
|
m_State = value;
|
ModelCenter.Instance.GetModel<TreasureModel>().HumanTreasureStateChange(base.id);
|
}
|
}
|
|
public HumanTreasure(int _id, int[] _potentialIds, Redpoint _skillLevelUpRedpoint, Redpoint _achievementPoint
|
, Redpoint _castSoulPoint)
|
: base(_id, _potentialIds, _skillLevelUpRedpoint, _achievementPoint)
|
{
|
castSoulRedpoint = _castSoulPoint;
|
}
|
|
public void UpdateTreasureState()
|
{
|
if (state == TreasureState.Locked)
|
{
|
humanState = HumanTreasureState.Locked;
|
return;
|
}
|
if (state == TreasureState.Collecting)
|
{
|
humanState = HumanTreasureState.Challenge;
|
return;
|
}
|
if (IsHighestStage && FuncOpen.Instance.IsFuncOpen(82))
|
{
|
humanState = HumanTreasureState.Potential;
|
}
|
else
|
{
|
humanState = HumanTreasureState.CastSoul;
|
}
|
}
|
|
public Redpoint castSoulRedpoint { get; private set; }
|
}
|
|
public class AchievementGroup
|
{
|
AchievementModel model { get { return ModelCenter.Instance.GetModel<AchievementModel>(); } }
|
public int group { get; private set; }
|
List<int> achievements = new List<int>();
|
|
public AchievementGroup(int _category)
|
{
|
group = _category;
|
}
|
|
public void AddAchievement(int _achievement)
|
{
|
if (!achievements.Contains(_achievement))
|
{
|
achievements.Add(_achievement);
|
}
|
}
|
|
public void Sort()
|
{
|
achievements.Sort(AchievementCompare);
|
}
|
|
public bool Contain(int _achievementId)
|
{
|
return achievements.Contains(_achievementId);
|
}
|
|
public bool IsAwardable()
|
{
|
var doingAchievement = GetDoingAchievement();
|
if (doingAchievement > 0)
|
{
|
Achievement achievement;
|
if (model.TryGetAchievement(doingAchievement, out achievement) && !achievement.completed)
|
{
|
return Achievement.IsReach(doingAchievement, achievement.progress);
|
}
|
}
|
return false;
|
}
|
|
public bool IsCompleted()
|
{
|
var achievementId = GetDoingAchievement();
|
Achievement doingAchievement;
|
if (model.TryGetAchievement(achievementId, out doingAchievement) && doingAchievement.completed)
|
{
|
return true;
|
}
|
for (int i = 0; i < achievements.Count; i++)
|
{
|
var id = achievements[i];
|
Achievement achievement;
|
if (model.TryGetAchievement(id, out achievement) && !achievement.completed)
|
{
|
return false;
|
}
|
}
|
|
return true;
|
}
|
|
public int GetDoingAchievement()
|
{
|
var achievementId = 0;
|
for (int i = 0; i < achievements.Count; i++)
|
{
|
var id = achievements[i];
|
Achievement achievement;
|
|
if (model.TryGetAchievement(id, out achievement) && !achievement.completed)
|
{
|
return id;
|
}
|
|
achievementId = id;
|
}
|
|
return achievementId;
|
}
|
|
public int GetLastAchievement()
|
{
|
if (achievements.Count == 0)
|
{
|
return 0;
|
}
|
else
|
{
|
var achievementId = GetDoingAchievement();
|
Achievement doingAchievement;
|
if (model.TryGetAchievement(achievementId, out doingAchievement) && doingAchievement.completed)
|
{
|
return achievementId;
|
}
|
return achievements[achievements.Count - 1];
|
}
|
}
|
|
private int AchievementCompare(int _lhs, int _rhs)
|
{
|
var configA = Config.Instance.Get<SuccessConfig>(_lhs);
|
var configB = Config.Instance.Get<SuccessConfig>(_rhs);
|
|
return configA.ReOrder.CompareTo(configB.ReOrder);
|
}
|
|
public static int Compare(AchievementGroup _lhs, AchievementGroup _rhs)
|
{
|
var awardableA = _lhs.IsAwardable();
|
var awardableB = _rhs.IsAwardable();
|
|
if (awardableA != awardableB)
|
{
|
return awardableA ? -1 : 1;
|
}
|
else
|
{
|
var completedA = _lhs.IsCompleted();
|
var completedB = _rhs.IsCompleted();
|
if (completedA != completedB)
|
{
|
return completedA.CompareTo(completedB);
|
}
|
else if (completedA && completedB)
|
{
|
return _lhs.group < _rhs.group ? -1 : 1;
|
}
|
else
|
{
|
var idA = _lhs.GetDoingAchievement();
|
var idB = _rhs.GetDoingAchievement();
|
|
var configA = Config.Instance.Get<SuccessConfig>(idA);
|
var configB = Config.Instance.Get<SuccessConfig>(idB);
|
|
if (configA == null)
|
{
|
return 1;
|
}
|
else if (configB == null)
|
{
|
return -1;
|
}
|
else if (configA == null && configB == null)
|
{
|
return 0;
|
}
|
else
|
{
|
return configA.ReOrder < configB.ReOrder ? -1 : 1;
|
}
|
}
|
}
|
}
|
|
}
|
|
public class TreasurePotential
|
{
|
public int id { get; private set; }
|
public int level { get; set; }
|
|
public TreasurePotential(int _id, int _level)
|
{
|
this.id = _id;
|
this.level = _level;
|
}
|
}
|
|
public struct PotentialBook
|
{
|
public int itemId;
|
public int needCount;
|
public int successRate;
|
public int levelUpId;
|
|
public PotentialBook(int _itemId, int _needCount, int _successRate, int _levelUpId)
|
{
|
this.itemId = _itemId;
|
this.needCount = _needCount;
|
this.successRate = _successRate;
|
this.levelUpId = _levelUpId;
|
}
|
|
}
|
|
public struct VIPKillNPCTreasure
|
{
|
public int level;
|
public long currentExp;
|
}
|
|
public class TreasureStage
|
{
|
public int id { get; private set; }
|
|
public int stage { get; set; }
|
public TreasureStageUnlock unlockType { get; private set; }
|
public Dictionary<int, int> propertyDict { get; private set; }
|
public Dictionary<int, int> skillDict { get; private set; }
|
public int func { get; private set; }
|
public Item item { get; private set; }
|
public int treasure { get; private set; }
|
public int treasureSoul { get; private set; }
|
public int exp { get; set; }
|
public int stateSfxId { get; private set; }
|
public const int selectedSfxId = 5144;
|
public string sfxGotState { get; private set; }
|
public string sfxUnGotState { get; private set; }
|
|
public TreasureStage(TreasureUpConfig _config)
|
{
|
id = _config.ID;
|
unlockType = TreasureStageUnlock.None;
|
if (_config.UnLockFuncID != 0)
|
{
|
unlockType = TreasureStageUnlock.Func;
|
func = _config.UnLockFuncID;
|
}
|
else if (_config.UnLockSkill != null && _config.UnLockSkill.Length > 1)
|
{
|
unlockType = TreasureStageUnlock.Skill;
|
skillDict = new Dictionary<int, int>();
|
for (int i = 0; i < _config.UnLockSkill.Length; i++)
|
{
|
skillDict.Add(i + 1, _config.UnLockSkill[i]);
|
}
|
}
|
else if (!string.IsNullOrEmpty(_config.AddAttr))
|
{
|
unlockType = TreasureStageUnlock.Property;
|
propertyDict = ConfigParse.GetDic<int, int>(_config.AddAttr);
|
}
|
else if (_config.ActiveMWID != 0)
|
{
|
unlockType = TreasureStageUnlock.Treasure;
|
treasure = _config.ActiveMWID;
|
}
|
else if (_config.SoulID != 0)
|
{
|
unlockType = TreasureStageUnlock.TreasureSoul;
|
treasureSoul = _config.SoulID;
|
}
|
else if (!string.IsNullOrEmpty(_config.ItemAward))
|
{
|
unlockType = TreasureStageUnlock.Item;
|
var itemArray = LitJson.JsonMapper.ToObject<int[]>(_config.ItemAward);
|
if (itemArray != null && itemArray.Length > 0)
|
{
|
item = new Item()
|
{
|
id = itemArray[0],
|
count = itemArray.Length > 1 ? itemArray[1] : 1,
|
bind = itemArray.Length > 2 ? (itemArray[2] == 1) : false,
|
};
|
}
|
}
|
|
exp = _config.NeedExp;
|
stage = _config.LV;
|
|
switch (unlockType)
|
{
|
case TreasureStageUnlock.Property:
|
stateSfxId = propertyDict.ContainsKey(6) ? 5142 : 5139;
|
sfxGotState = propertyDict.ContainsKey(6) ? "Effect_FaBao_Icon_ShengMing" : "Effect_FaBao_Icon_GongJi";
|
sfxUnGotState = propertyDict.ContainsKey(6) ? "Effect_FaBao_Icon_ShengMing" : "Effect_FaBao_Icon_GongJi";
|
break;
|
default:
|
stateSfxId = 5141;
|
sfxGotState = "Effect_FaBao_Icon_JiNeng_01";
|
sfxUnGotState = "Effect_FaBao_Icon_JiNeng_02";
|
break;
|
}
|
}
|
|
public int GetSkill(int _job)
|
{
|
if (skillDict.ContainsKey(_job))
|
{
|
return skillDict[_job];
|
}
|
return 0;
|
}
|
|
public int GetFightPower()
|
{
|
switch (unlockType)
|
{
|
case TreasureStageUnlock.Property:
|
return UIHelper.GetFightPower(propertyDict);
|
case TreasureStageUnlock.Skill:
|
var _job = PlayerDatas.Instance.baseData.Job;
|
var _skillCfg = Config.Instance.Get<SkillConfig>(GetSkill(_job));
|
if (_skillCfg != null)
|
{
|
return _skillCfg.FightPower;
|
}
|
break;
|
}
|
return 0;
|
}
|
}
|
|
public enum TreasureStageUnlock
|
{
|
None,
|
Property,
|
Skill,
|
Func,
|
Item,
|
Treasure,
|
TreasureSoul,
|
}
|
}
|
|
|
|
