//--------------------------------------------------------
|
// [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_Level;
|
public int level
|
{
|
get { return m_Level; }
|
set { m_Level = value; }
|
}
|
|
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; }
|
}
|
|
#region 旧数据
|
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 = ConfigManager.Instance.GetTemplate<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 unLockFunc
|
{
|
get; private set;
|
}
|
|
public int unLockPrivilege
|
{
|
get; private 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 Item[] needItems { get; private set; }
|
|
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 = ConfigManager.Instance.GetTemplate<TreasureConfig>(this.id);
|
List<int> _expAchievements;
|
if (SuccessConfig.TryGetTreasureExpAchievements(_id, out _expAchievements))
|
{
|
achievements.AddRange(_expAchievements);
|
}
|
|
foreach (var achievement in achievements)
|
{
|
var achievementConfig = ConfigManager.Instance.GetTemplate<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 = ConfigManager.Instance.GetTemplate<SkillConfig>(skillId);
|
if (skillConfig == null)
|
{
|
continue;
|
}
|
|
for (int j = 0; j < GeneralConfig.Instance.openJobs.Length; j++)
|
{
|
var job = GeneralConfig.Instance.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));
|
}
|
}
|
|
}
|
|
if (!string.IsNullOrEmpty(config.NeedItem))
|
{
|
try
|
{
|
var stringSet = config.NeedItem.Split('|');
|
needItems = new Item[stringSet.Length];
|
for (int i = 0; i < needItems.Length; i++)
|
{
|
var itemStrings = stringSet[i].Split('_');
|
needItems[i] = new Item(int.Parse(itemStrings[0]), int.Parse(itemStrings[1]));
|
}
|
}
|
catch (Exception ex)
|
{
|
Debug.Log(ex.StackTrace);
|
}
|
}
|
else
|
{
|
needItems = null;
|
}
|
}
|
|
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 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 = ConfigManager.Instance.GetTemplate<SuccessConfig>(_lhs);
|
var configB = ConfigManager.Instance.GetTemplate<SuccessConfig>(_rhs);
|
|
return configA.ReOrder < configB.ReOrder ? -1 : 1;
|
}
|
#endregion
|
|
public TreasureSpecialData specialData { get; private set; }
|
|
public List<TreasureStage> treasureStages = new List<TreasureStage>();
|
public void UpdateTreasureStage(TreasureUpConfig _cfg)
|
{
|
TreasureStage _stage;
|
if (_cfg.UnLockFuncID != 0)
|
{
|
_stage = new TreasureStage(_cfg.UnLockFuncID);
|
unLockFunc = _stage.func;
|
}
|
else if (_cfg.Privilege != 0)
|
{
|
_stage = new TreasureStage(_cfg.Privilege, TreasureStageUnlock.Privilege);
|
specialData = _stage.specialData;
|
unLockPrivilege = _stage.privilege;
|
}
|
else if (_cfg.UnLockSkill != null && _cfg.UnLockSkill.Length > 1)
|
{
|
_stage = new TreasureStage(_cfg.UnLockSkill);
|
}
|
else if (!_cfg.AddAttr.Equals(string.Empty))
|
{
|
_stage = new TreasureStage(_cfg.AddAttr);
|
}
|
else
|
{
|
_stage = new TreasureStage();
|
}
|
_stage.exp = _cfg.NeedExp;
|
_stage.stage = _cfg.LV;
|
_stage.limitLevel = _cfg.LVLimit;
|
treasureStages.Add(_stage);
|
}
|
|
public void UpdateTreasureLevelExp(int _lv, int _exp, bool _hasClickChallenge)
|
{
|
stage = _lv;
|
exp = _exp;
|
hasClickChallenge = _hasClickChallenge;
|
if ((this is HumanTreasure) && IsMaxStage())
|
{
|
(this as HumanTreasure).humanState = HumanTreasureState.Potential;
|
}
|
}
|
|
public bool IsMaxStage()
|
{
|
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 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;
|
}
|
set
|
{
|
m_State = value;
|
if (value == HumanTreasureState.CastSoul)
|
{
|
if (IsMaxStage())
|
{
|
m_State = HumanTreasureState.Potential;
|
}
|
}
|
ModelCenter.Instance.GetModel<TreasureModel>().HumanTreasureStateChange(base.id);
|
}
|
}
|
|
public HumanTreasure(int _id)
|
: base(_id)
|
{
|
|
}
|
|
public HumanTreasure(int _id, int[] _potentialIds, Redpoint _skillLevelUpRedpoint, Redpoint _achievementPoint
|
, Redpoint _castSoulPoint)
|
: base(_id, _potentialIds, _skillLevelUpRedpoint, _achievementPoint)
|
{
|
castSoulRedpoint = _castSoulPoint;
|
}
|
|
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;
|
|
var config = ConfigManager.Instance.GetTemplate<SuccessConfig>(id);
|
if (config == null || PlayerDatas.Instance.baseData.LV < config.Condition3)
|
{
|
continue;
|
}
|
|
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 = ConfigManager.Instance.GetTemplate<SuccessConfig>(_lhs);
|
var configB = ConfigManager.Instance.GetTemplate<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 = ConfigManager.Instance.GetTemplate<SuccessConfig>(idA);
|
var configB = ConfigManager.Instance.GetTemplate<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 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 int privilege { get; private set; }
|
public int exp { get; set; }
|
public TreasureSpecialData specialData { get; private 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 int limitLevel { get; set; }
|
|
public TreasureStage()
|
{
|
unlockType = TreasureStageUnlock.None;
|
}
|
|
public TreasureStage(int _value, TreasureStageUnlock _type = TreasureStageUnlock.Func)
|
{
|
unlockType = _type;
|
func = _type == TreasureStageUnlock.Func ? _value : 0;
|
privilege = _type == TreasureStageUnlock.Privilege ? _value : 0;
|
stateSfxId = 5141;
|
sfxGotState = "Effect_FaBao_Icon_JiNeng_01";
|
sfxUnGotState = "Effect_FaBao_Icon_JiNeng_02";
|
//stateSfxId = _type == TreasureStageUnlock.Func ? 5140 : 5143;
|
//sfxGotState = _type == TreasureStageUnlock.Func ? "Effect_FaBao_Icon_GongNeng_01" : "Effect_FaBao_Icon_TeQuan_02";
|
//sfxUnGotState = _type == TreasureStageUnlock.Func ? "Effect_FaBao_Icon_GongNeng" : "Effect_FaBao_Icon_TeQuan";
|
if (_type == TreasureStageUnlock.Privilege)
|
{
|
SetSpecial();
|
}
|
}
|
|
public TreasureStage(string _property)
|
{
|
unlockType = TreasureStageUnlock.Property;
|
propertyDict = ConfigParse.GetDic<int, int>(_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";
|
}
|
|
public TreasureStage(int[] _skills)
|
{
|
unlockType = TreasureStageUnlock.Skill;
|
stateSfxId = 5141;
|
sfxGotState = "Effect_FaBao_Icon_JiNeng_01";
|
sfxUnGotState = "Effect_FaBao_Icon_JiNeng_02";
|
skillDict = new Dictionary<int, int>();
|
for (int i = 0; i < _skills.Length; i++)
|
{
|
skillDict.Add(i + 1, _skills[i]);
|
}
|
}
|
|
public void SetSpecial()
|
{
|
var _priviligeCfg = ConfigManager.Instance.GetTemplate<TreasurePrivilegeConfig>(privilege);
|
specialData = new TreasureSpecialData((TreasurePrivilege)_priviligeCfg.PrivilegeID);
|
}
|
|
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 = ConfigManager.Instance.GetTemplate<SkillConfig>(GetSkill(_job));
|
if (_skillCfg != null)
|
{
|
return _skillCfg.FightPower;
|
}
|
break;
|
case TreasureStageUnlock.Privilege:
|
return specialData.GetFightPower();
|
}
|
return 0;
|
}
|
}
|
|
public enum TreasureStageUnlock
|
{
|
None,
|
Property,
|
Skill,
|
Func,
|
Privilege,
|
}
|
|
public enum TreasurePrivilege
|
{
|
Property = 1,
|
DemonJarAtk = 2,
|
StrengthenAdd = 3,
|
RuneBreakExpAdd = 4,
|
MountAtk = 5,
|
PetHp = 6,
|
Boss = 7,
|
Wing = 8,
|
Suit = 9,
|
Wash = 10,
|
Sign = 11,
|
}
|
|
public enum TreasurePrivilegeState
|
{
|
Doing = 0,
|
Reward = 1,
|
Complete = 2
|
}
|
|
public class TreasureSpecialData
|
{
|
public TreasurePrivilege type { get; private set; }
|
public int progress { get; private set; }
|
public int totalProgress { get; private set; }
|
public int effectValue { get; private set; }
|
public List<AwardItem> items { get; private set; }
|
public Dictionary<int, int> propertyDict { get; private set; }
|
public Redpoint privilegeRedpoint { get; private set; }
|
|
private TreasurePrivilegeState m_State = TreasurePrivilegeState.Doing;
|
public TreasurePrivilegeState state
|
{
|
get { return m_State; }
|
set { m_State = value; }
|
}
|
|
public int presentFinishCount { get; set; }
|
public int presentGetCount { get; set; }
|
public bool itemGet { get; set; }
|
|
public TreasureSpecialData(TreasurePrivilege _type)
|
{
|
type = _type;
|
var config = ConfigManager.Instance.GetTemplate<TreasurePrivilegeConfig>((int)_type);
|
progress = Mathf.Max(1, config.singleValue);
|
totalProgress = config.maxValue;
|
var _effectValue = 0;
|
int.TryParse(config.EffectValue, out _effectValue);
|
effectValue = _effectValue;
|
if (!string.IsNullOrEmpty(config.attr))
|
{
|
var propertyJson = LitJson.JsonMapper.ToObject(config.attr);
|
propertyDict = new Dictionary<int, int>();
|
foreach (var _key in propertyJson.Keys)
|
{
|
var _property = int.Parse(_key);
|
var _value = int.Parse(propertyJson[_key].ToJson());
|
propertyDict.Add(_property, _value);
|
}
|
}
|
if (!string.IsNullOrEmpty(config.itemAward))
|
{
|
var itemArray = LitJson.JsonMapper.ToObject<int[][]>(config.itemAward);
|
if (itemArray != null && itemArray.Length > 0)
|
{
|
items = new List<AwardItem>();
|
for (int i = 0; i < itemArray.Length; i++)
|
{
|
var _array = itemArray[i];
|
items.Add(new AwardItem()
|
{
|
isBind = _array[2],
|
item = new Item()
|
{
|
id = _array[0],
|
count = _array[1],
|
},
|
});
|
}
|
}
|
}
|
|
if (type == TreasurePrivilege.PetHp)
|
{
|
var petCount = ConfigManager.Instance.GetAllValues<PetInfoConfig>().Count;
|
totalProgress = petCount;
|
}
|
else if (type == TreasurePrivilege.MountAtk)
|
{
|
var mountConfigs = ConfigManager.Instance.GetAllValues<HorseConfig>();
|
var maxlv = 0;
|
for (int i = 0; i < mountConfigs.Count; i++)
|
{
|
maxlv += mountConfigs[i].MaxLV;
|
}
|
totalProgress = maxlv;
|
}
|
else if (type == TreasurePrivilege.StrengthenAdd)
|
{
|
var configs = ConfigManager.Instance.GetAllValues<ItemPlusSumAttrConfig>();
|
totalProgress = configs[configs.Count - 1].countNeed;
|
}
|
|
switch (_type)
|
{
|
case TreasurePrivilege.DemonJarAtk:
|
case TreasurePrivilege.StrengthenAdd:
|
case TreasurePrivilege.MountAtk:
|
case TreasurePrivilege.PetHp:
|
case TreasurePrivilege.Boss:
|
case TreasurePrivilege.Wash:
|
privilegeRedpoint = new Redpoint(TreasureModel.TREASURE_SOUL_ID, TreasureModel.TREASURE_SOUL_ID * 100 + (int)type);
|
break;
|
}
|
}
|
|
public int GetPrivilegeValue(int _index = 0)
|
{
|
switch (type)
|
{
|
case TreasurePrivilege.RuneBreakExpAdd:
|
return effectValue;
|
case TreasurePrivilege.DemonJarAtk:
|
case TreasurePrivilege.Suit:
|
return effectValue;
|
case TreasurePrivilege.Wing:
|
case TreasurePrivilege.StrengthenAdd:
|
return effectValue;
|
}
|
return 0;
|
}
|
|
public void UpdateState()
|
{
|
switch (type)
|
{
|
case TreasurePrivilege.Property:
|
case TreasurePrivilege.RuneBreakExpAdd:
|
case TreasurePrivilege.Wing:
|
case TreasurePrivilege.Suit:
|
state = TreasurePrivilegeState.Complete;
|
break;
|
case TreasurePrivilege.Boss:
|
case TreasurePrivilege.DemonJarAtk:
|
case TreasurePrivilege.PetHp:
|
case TreasurePrivilege.MountAtk:
|
privilegeRedpoint.state = RedPointState.None;
|
if (presentFinishCount >= totalProgress && (presentGetCount / progress) >= (totalProgress / progress))
|
{
|
state = TreasurePrivilegeState.Complete;
|
}
|
else if (presentGetCount > 0 && presentFinishCount / progress < presentGetCount / progress)
|
{
|
state = TreasurePrivilegeState.Reward;
|
privilegeRedpoint.state = RedPointState.Simple;
|
}
|
else
|
{
|
state = TreasurePrivilegeState.Doing;
|
}
|
break;
|
case TreasurePrivilege.Wash:
|
privilegeRedpoint.state = itemGet ? RedPointState.None : RedPointState.Simple;
|
state = itemGet ? TreasurePrivilegeState.Doing : TreasurePrivilegeState.Reward;
|
break;
|
case TreasurePrivilege.StrengthenAdd:
|
privilegeRedpoint.state = RedPointState.None;
|
var strengthen = ModelCenter.Instance.GetModel<PlayerStrengthengDatas>();
|
var playerpack = ModelCenter.Instance.GetModel<PlayerPackModel>();
|
presentGetCount = 0;
|
foreach (var value in strengthen._EqInfo.Values)
|
{
|
ItemModel itemModel = playerpack.GetItemModelByIndex(PackType.rptEquip, value.EquipIndex);
|
if (itemModel != null)
|
{
|
presentGetCount += value.EquipPartStarLV;
|
}
|
}
|
var configs = ConfigManager.Instance.GetAllValues<ItemPlusSumAttrConfig>();
|
bool contains = configs.FindIndex((x) =>
|
{
|
return x.countNeed > presentFinishCount && presentGetCount >= x.countNeed;
|
}) != -1;
|
if (presentFinishCount >= totalProgress && presentGetCount >= totalProgress)
|
{
|
state = TreasurePrivilegeState.Complete;
|
}
|
else if (contains)
|
{
|
state = TreasurePrivilegeState.Reward;
|
privilegeRedpoint.state = RedPointState.Simple;
|
}
|
else
|
{
|
state = TreasurePrivilegeState.Doing;
|
}
|
break;
|
}
|
}
|
|
public string ProgressDisplay()
|
{
|
switch (type)
|
{
|
case TreasurePrivilege.DemonJarAtk:
|
case TreasurePrivilege.PetHp:
|
case TreasurePrivilege.MountAtk:
|
case TreasurePrivilege.Boss:
|
if (state == TreasurePrivilegeState.Complete) { return UIHelper.GetTextColorByItemColor(TextColType.Green, totalProgress.ToString(), true); }
|
else if (state == TreasurePrivilegeState.Doing)
|
{
|
return StringUtility.Contact(UIHelper.GetTextColorByItemColor(TextColType.Red, presentGetCount.ToString(), true), "/", (presentFinishCount / progress + 1) * progress);
|
}
|
else if (state == TreasurePrivilegeState.Reward)
|
{
|
var _completeCount = (presentFinishCount / progress + 1) * progress;
|
return StringUtility.Contact(UIHelper.GetTextColorByItemColor(TextColType.Green, presentGetCount.ToString(), true), "/", _completeCount);
|
}
|
break;
|
case TreasurePrivilege.StrengthenAdd:
|
var configs = ConfigManager.Instance.GetAllValues<ItemPlusSumAttrConfig>();
|
var next = configs.Count - 1;
|
for (int i = 0; i < configs.Count; i++)
|
{
|
if (configs[i].countNeed > presentFinishCount)
|
{
|
next = i;
|
break;
|
}
|
}
|
if (state == TreasurePrivilegeState.Complete) { return totalProgress.ToString(); }
|
else if (state == TreasurePrivilegeState.Doing
|
|| state == TreasurePrivilegeState.Reward)
|
{
|
var colortype = presentGetCount >= configs[next].countNeed ? TextColType.Green : TextColType.Red;
|
return StringUtility.Contact(UIHelper.GetTextColorByItemColor(colortype, presentGetCount.ToString(), true), "/", configs[next].countNeed);
|
}
|
break;
|
}
|
return string.Empty;
|
}
|
|
public void GetReward()
|
{
|
switch (type)
|
{
|
case TreasurePrivilege.MountAtk:
|
case TreasurePrivilege.DemonJarAtk:
|
case TreasurePrivilege.PetHp:
|
case TreasurePrivilege.Boss:
|
case TreasurePrivilege.Wash:
|
var _pak = new CA504_tagCMPlayerGetReward();
|
_pak.RewardType = (int)GotServerRewardType.Def_RewardType_TreasureSoul;
|
_pak.DataEx = (uint)type;
|
_pak.DataExStrLen = 0;
|
_pak.DataExStr = string.Empty;
|
GameNetSystem.Instance.SendInfo(_pak);
|
break;
|
case TreasurePrivilege.StrengthenAdd:
|
var configs = ConfigManager.Instance.GetAllValues<ItemPlusSumAttrConfig>();
|
var present = 0;
|
for (int i = 0; i < configs.Count; i++)
|
{
|
if (presentGetCount >= configs[i].countNeed)
|
{
|
present = i;
|
}
|
}
|
CA503_tagCMActiveAllEquipAttr pak = new CA503_tagCMActiveAllEquipAttr();
|
pak.Type = 0;
|
pak.Cnt = (uint)configs[present].countNeed;
|
GameNetSystem.Instance.SendInfo(pak);
|
break;
|
}
|
}
|
|
public int GetFightPower()
|
{
|
var _fightPower = 0;
|
if (propertyDict != null)
|
{
|
_fightPower += UIHelper.GetFightPower(propertyDict);
|
}
|
return _fightPower;
|
}
|
}
|
}
|
|
|
|
