public AbilityData CreateDeriveAbility(AbilityDeriveParam deriveParam)
{
AbilityData abilityData = new AbilityData();
abilityData.Setup(this.Owner, this.UniqueID, deriveParam.DeriveAbilityIname, this.Exp, 0);
abilityData.m_BaseAbility = this;
abilityData.IsNoneCategory = this.IsNoneCategory;
abilityData.m_AbilityDeriveParam = deriveParam;
return(abilityData);
}
public void AddAbility(string base_ability_iname, AbilityDeriveParam derive_param, string derive_ability_iname, bool is_enable)
{
if (this.derive_abilities == null)
{
this.derive_abilities = new List <ViewDeriveAbilityData>();
}
this.base_ability = MonoSingleton <GameManager> .Instance.MasterParam.GetAbilityParam(base_ability_iname);
if (is_enable)
{
this.is_enable_base_ability = false;
}
this.derive_abilities.Add(new ViewDeriveAbilityData()
{
ability = MonoSingleton <GameManager> .Instance.MasterParam.GetAbilityParam(derive_ability_iname),
is_enable = is_enable
});
this.ability_derive_param = derive_param;
}
private GameObject CreateDeriveAbilityItem(AbilityDeriveParam abilityDeriveParam)
{
GameObject gameObject = (GameObject)null;
if (this.m_DeriveAbilitys == null)
{
this.m_DeriveAbilitys = new List <GameObject>();
}
if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.m_DeriveAbilityTemplate, (UnityEngine.Object)null))
{
gameObject = (GameObject)UnityEngine.Object.Instantiate <GameObject>((M0)this.m_DeriveAbilityTemplate);
DataSource.Bind <SkillAbilityDeriveParam>(gameObject, abilityDeriveParam.m_SkillAbilityDeriveParam);
DataSource.Bind <AbilityParam>(gameObject, abilityDeriveParam.m_DeriveParam);
DataSource.Bind <AbilityDeriveParam>(gameObject, abilityDeriveParam);
gameObject.SetActive(true);
gameObject.get_transform().SetParent((Transform)this.m_DeriveAbilityListRoot, false);
this.m_DeriveAbilitys.Add(gameObject);
this.RegisterHoldEvent(gameObject);
}
return(gameObject);
}
private void BindData(GameObject target, AbilityParam ability_data, AbilityDeriveParam ability_derive_param)
{
DataSource.Bind <AbilityParam>(target, ability_data);
if (ability_data.condition_units != null)
{
for (int index = 0; index < ability_data.condition_units.Length; ++index)
{
if (!string.IsNullOrEmpty(ability_data.condition_units[index]))
{
UnitParam unitParam = MonoSingleton <GameManager> .Instance.MasterParam.GetUnitParam(ability_data.condition_units[index]);
if (unitParam != null)
{
DataSource.Bind <UnitParam>(target, unitParam);
}
}
}
}
if (ability_data.condition_jobs != null)
{
for (int index = 0; index < ability_data.condition_jobs.Length; ++index)
{
if (!string.IsNullOrEmpty(ability_data.condition_jobs[index]))
{
JobParam jobParam = MonoSingleton <GameManager> .Instance.MasterParam.GetJobParam(ability_data.condition_jobs[index]);
if (jobParam != null)
{
DataSource.Bind <JobParam>(target, jobParam);
}
}
}
}
if (ability_derive_param == null)
{
return;
}
DataSource.Bind <AbilityDeriveParam>(target, ability_derive_param);
}
private static List <SkillAbilityDeriveListItem.ViewContentAbilityParam> CreateViewContentAbilityParams(List <AbilityDeriveParam> deriveAbilityParams)
{
List <SkillAbilityDeriveListItem.ViewContentAbilityParam> contentAbilityParamList = new List <SkillAbilityDeriveListItem.ViewContentAbilityParam>();
using (List <AbilityDeriveParam> .Enumerator enumerator = deriveAbilityParams.GetEnumerator())
{
while (enumerator.MoveNext())
{
AbilityDeriveParam abilityDeriveParam = enumerator.Current;
SkillAbilityDeriveListItem.ViewContentAbilityParam contentAbilityParam = contentAbilityParamList.Find((Predicate <SkillAbilityDeriveListItem.ViewContentAbilityParam>)(content => content.m_BaseAbilityParam == abilityDeriveParam.m_BaseParam));
if (contentAbilityParam == null)
{
contentAbilityParam = new SkillAbilityDeriveListItem.ViewContentAbilityParam();
contentAbilityParam.m_AbilityDeriveParam = new List <AbilityDeriveParam>();
contentAbilityParamList.Add(contentAbilityParam);
}
contentAbilityParam.m_BaseAbilityParam = abilityDeriveParam.m_BaseParam;
contentAbilityParam.m_AbilityDeriveParam.Add(abilityDeriveParam);
}
}
return(contentAbilityParamList);
}
private List <AbilityDeriveParam> GetAbilityDeriveParams(MasterParam masterParam)
{
List <AbilityDeriveParam> abilityDeriveParamList = new List <AbilityDeriveParam>();
if (this.base_abils == null || this.derive_abils == null)
{
return(abilityDeriveParamList);
}
for (int index = 0; index < this.base_abils.Length; ++index)
{
string baseAbil = this.base_abils[index];
string deriveAbil = this.derive_abils[index];
if ((!string.IsNullOrEmpty(baseAbil) || !string.IsNullOrEmpty(deriveAbil)) && (!string.IsNullOrEmpty(baseAbil) && !string.IsNullOrEmpty(deriveAbil)))
{
AbilityDeriveParam abilityDeriveParam = new AbilityDeriveParam();
abilityDeriveParam.m_BaseParam = masterParam.GetAbilityParam(baseAbil);
abilityDeriveParam.m_DeriveParam = masterParam.GetAbilityParam(deriveAbil);
abilityDeriveParam.m_SkillAbilityDeriveParam = this;
abilityDeriveParamList.Add(abilityDeriveParam);
}
}
return(abilityDeriveParamList);
}
public void Setup(SkillAbilityDeriveParam skillAbilityDeriveParam, List <SkillAbilityDeriveParam> additionalSkillAbilityDeriveParams)
{
this.m_SkillDeriveData = new List <SkillDeriveData>();
this.m_AbilityDeriveData = new List <AbilityDeriveData>();
this.m_SkillAbilityDeriveParam = skillAbilityDeriveParam;
IEnumerable <SkillDeriveData> collection1 = this.m_SkillAbilityDeriveParam.SkillDeriveParams.Select <SkillDeriveParam, SkillDeriveData>((Func <SkillDeriveParam, SkillDeriveData>)(param => new SkillDeriveData(param)));
IEnumerable <AbilityDeriveData> collection2 = this.m_SkillAbilityDeriveParam.AbilityDeriveParams.Select <AbilityDeriveParam, AbilityDeriveData>((Func <AbilityDeriveParam, AbilityDeriveData>)(param => new AbilityDeriveData(param)));
this.m_SkillDeriveData.AddRange(collection1);
this.m_AbilityDeriveData.AddRange(collection2);
Dictionary <string, int> dictionary = new Dictionary <string, int>();
using (List <SkillDeriveData> .Enumerator enumerator = this.m_SkillDeriveData.GetEnumerator())
{
while (enumerator.MoveNext())
{
SkillDeriveData current = enumerator.Current;
if (!dictionary.ContainsKey(current.Param.BaseSkillIname))
{
dictionary.Add(current.Param.BaseSkillIname, this.MasterIndex);
}
}
}
using (List <AbilityDeriveData> .Enumerator enumerator = this.m_AbilityDeriveData.GetEnumerator())
{
while (enumerator.MoveNext())
{
AbilityDeriveData current = enumerator.Current;
if (!dictionary.ContainsKey(current.Param.BaseAbilityIname))
{
dictionary.Add(current.Param.BaseAbilityIname, this.MasterIndex);
}
}
}
using (List <SkillAbilityDeriveParam> .Enumerator enumerator1 = additionalSkillAbilityDeriveParams.GetEnumerator())
{
while (enumerator1.MoveNext())
{
SkillAbilityDeriveParam current1 = enumerator1.Current;
if (!this.m_AdditionalSkillAbilityDeriveParam.Contains(current1))
{
this.m_AdditionalSkillAbilityDeriveParam.Add(current1);
}
List <SkillDeriveParam> skillDeriveParams = current1.SkillDeriveParams;
List <AbilityDeriveParam> abilityDeriveParams = current1.AbilityDeriveParams;
using (List <SkillDeriveParam> .Enumerator enumerator2 = skillDeriveParams.GetEnumerator())
{
while (enumerator2.MoveNext())
{
SkillDeriveParam current2 = enumerator2.Current;
int num = -1;
if (dictionary.TryGetValue(current2.BaseSkillIname, out num))
{
num = Mathf.Min(current2.MasterIndex, num);
dictionary[current2.BaseSkillIname] = num;
}
else
{
dictionary.Add(current2.BaseSkillIname, current2.MasterIndex);
}
this.m_SkillDeriveData.Add(new SkillDeriveData(current2)
{
IsAdd = true
});
}
}
using (List <AbilityDeriveParam> .Enumerator enumerator2 = abilityDeriveParams.GetEnumerator())
{
while (enumerator2.MoveNext())
{
AbilityDeriveParam current2 = enumerator2.Current;
int num = -1;
if (dictionary.TryGetValue(current2.BaseAbilityIname, out num))
{
num = Mathf.Min(current2.MasterIndex, num);
dictionary[current2.BaseAbilityIname] = num;
}
else
{
dictionary.Add(current2.BaseAbilityIname, current2.MasterIndex);
}
this.m_AbilityDeriveData.Add(new AbilityDeriveData(current2)
{
IsAdd = true
});
}
}
}
}
using (List <AbilityDeriveData> .Enumerator enumerator = this.m_AbilityDeriveData.GetEnumerator())
{
while (enumerator.MoveNext())
{
AbilityDeriveData current = enumerator.Current;
int num = -1;
if (dictionary.TryGetValue(current.Param.BaseAbilityIname, out num))
{
current.IsDisable = current.Param.MasterIndex > num;
}
}
}
using (List <SkillDeriveData> .Enumerator enumerator = this.m_SkillDeriveData.GetEnumerator())
{
while (enumerator.MoveNext())
{
SkillDeriveData current = enumerator.Current;
int num = -1;
if (dictionary.TryGetValue(current.Param.BaseSkillIname, out num))
{
current.IsDisable = current.Param.MasterIndex > num;
}
}
}
}
