//--------------------------------------------------------
|
// [Author]: 第二世界
|
// [ Date ]: Monday, October 09, 2017
|
//--------------------------------------------------------
|
using UnityEngine;
|
using System.Collections;
|
using System.Collections.Generic;
|
using UnityEngine.UI;
|
|
using System;
|
using System.Text.RegularExpressions;
|
|
namespace vnxbqy.UI
|
{
|
|
public class Treasure
|
{
|
public int id { get; private set; }
|
public int exp { get; private set; }
|
public int level { get; private set; }
|
public TreasureState state { get; set; }
|
|
public List<TreasureStage> treasureStages = new List<TreasureStage>();
|
|
public Treasure(int id)
|
{
|
this.id = id;
|
}
|
|
public int skillId
|
{
|
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 void RefreshLevel(int level, int exp)
|
{
|
this.level = level;
|
this.exp = exp;
|
}
|
|
public void ParseStage(TreasureUpConfig config)
|
{
|
treasureStages.Add(new TreasureStage(config));
|
}
|
}
|
|
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 exp { get; set; }
|
public int powerEx { get; set; }
|
|
public TreasureStage(TreasureUpConfig config)
|
{
|
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);
|
}
|
|
exp = config.NeedExp;
|
stage = config.LV;
|
powerEx = config.PowerEx;
|
}
|
|
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 = SkillConfig.Get(GetSkill(job));
|
if (_skillCfg != null)
|
{
|
return _skillCfg.FightPower;
|
}
|
break;
|
}
|
return 0;
|
}
|
}
|
|
public class TreasureDungeon
|
{
|
public int treasureId;
|
public List<TreasureDungeonInfo> dungeonInfos = new List<TreasureDungeonInfo>();
|
private int m_Level = 0;
|
|
public int currentLevel
|
{
|
get
|
{
|
var model = ModelCenter.Instance.GetModel<TreasureModel>();
|
Treasure treasure;
|
if (model.TryGetTreasure(treasureId, out treasure)
|
&& treasure.state == TreasureState.Collected)
|
{
|
return maxLevel;
|
}
|
return m_Level;
|
}
|
set
|
{
|
m_Level = value;
|
}
|
}
|
|
public int maxLevel { get; private set; }
|
|
public Redpoint challengeRedpoint;
|
|
public TreasureDungeon(int treasureId,Redpoint challengeRedpoint)
|
{
|
this.treasureId = treasureId;
|
this.challengeRedpoint = challengeRedpoint;
|
}
|
|
public void ParseDungeonInfo(TreasureDungeonConfig config)
|
{
|
if (dungeonInfos.FindIndex((x) =>
|
{
|
return x.level == config.Level;
|
}) == -1)
|
{
|
var json = LitJson.JsonMapper.ToObject(config.Attr);
|
var propertyDict = new Dictionary<int, int>();
|
foreach (var key in json.Keys)
|
{
|
var property = int.Parse(key);
|
var value = int.Parse(json[key].ToString());
|
propertyDict.Add(property, value);
|
}
|
var dungeonInfo = new TreasureDungeonInfo()
|
{
|
key = config.ID,
|
fightPower = config.fightPower,
|
level = config.Level,
|
propertyDict = propertyDict,
|
lineId = config.LineID,
|
defense = config.defense,
|
};
|
dungeonInfos.Add(dungeonInfo);
|
|
if (config.Level > maxLevel)
|
{
|
maxLevel = config.Level;
|
}
|
}
|
}
|
|
public TreasureDungeonInfo Get(int level)
|
{
|
return dungeonInfos.Find((x) =>
|
{
|
return x.level == level;
|
});
|
}
|
|
public Dictionary<int, int> GetUpperProperty(int level)
|
{
|
var lastDungeonInfo = Get(level - 1);
|
var currentDungeonInfo = Get(level);
|
if (currentDungeonInfo.Equals(default(TreasureDungeonInfo)))
|
{
|
return null;
|
}
|
var dict = new Dictionary<int, int>();
|
foreach (var key in currentDungeonInfo.propertyDict.Keys)
|
{
|
if (level == 1)
|
{
|
dict.Add(key, currentDungeonInfo.propertyDict[key]);
|
}
|
else
|
{
|
if (lastDungeonInfo.propertyDict.ContainsKey(key))
|
{
|
if (lastDungeonInfo.propertyDict[key] >= currentDungeonInfo.propertyDict[key])
|
{
|
continue;
|
}
|
dict.Add(key, currentDungeonInfo.propertyDict[key] - lastDungeonInfo.propertyDict[key]);
|
}
|
else
|
{
|
dict.Add(key, currentDungeonInfo.propertyDict[key]);
|
}
|
}
|
}
|
return dict;
|
}
|
}
|
|
public struct TreasureDungeonInfo
|
{
|
public int key;
|
public int lineId;
|
public int level;
|
public Dictionary<int, int> propertyDict;
|
public int fightPower;
|
public int defense;
|
}
|
|
public enum TreasureStageUnlock
|
{
|
None,
|
Property,
|
Skill,
|
Func,
|
}
|
}
|
|
|
|
