public static SkillTreeUnit GetMaxLevelSkillByType(int type)
{
SkillTreeUnit temp = null;
foreach (KeyValuePair <int, Dictionary <int, Dictionary <int, SkillTreeUnit> > > kvp1 in _skillTreeInfo)
{
foreach (KeyValuePair <int, Dictionary <int, SkillTreeUnit> > kvp2 in kvp1.Value)
{
foreach (KeyValuePair <int, SkillTreeUnit> item in kvp2.Value)
{
if (item.Value._skillType == type)
{
if (temp == null)
{
temp = item.Value;
}
else
{
if (temp._level < item.Value._level)
{
temp = item.Value;
}
}
}
}
}
}
return(temp);
}
public ulong GetNextExpBySkillType(int skillType)
{
SkillTreeUnit skill = FindSkillUnit(skillType);
SkillTreeUnit nextSkill;
if (skill != null)
{
int nextLevel = skill._level + 1;
nextSkill = SkillTreeInfo.GetSkillUnit(skillType, nextLevel);
if (nextSkill != null)
{
return(nextSkill._exp);
}
else
{
return(0);
}
}
else
{
nextSkill = SkillTreeInfo.GetMinLevelSkillByType(skillType);
if (nextSkill != null)
{
return(nextSkill._exp);
}
else
{
return(0);
}
}
}
public static void LoadData()
{
_skillTreeInfo = new Dictionary <int, Dictionary <int, Dictionary <int, SkillTreeUnit> > >();
SqliteDataReader reader = LocalDatabase.Instance.ReadFullTable("skilltree");
// int nFieldCount = reader.FieldCount;
while (reader.Read())
{
int id = Convert.ToInt32(reader.GetString(reader.GetOrdinal("id")));
int maintype = Convert.ToInt32(reader.GetString(reader.GetOrdinal("maintype")));
int skilltype = Convert.ToInt32(reader.GetString(reader.GetOrdinal("skilltype")));
int skillgroup = Convert.ToInt32(reader.GetString(reader.GetOrdinal("skillgroup")));
int skillgrade = Convert.ToInt32(reader.GetString(reader.GetOrdinal("skillgrade")));
int level = Convert.ToInt32(reader.GetString(reader.GetOrdinal("level")));
UInt64 exp = Convert.ToUInt64(reader.GetString(reader.GetOrdinal("exp")));
string parent = reader.GetString(reader.GetOrdinal("parent"));
string value = reader.GetString(reader.GetOrdinal("value"));
string sprName = reader.GetString(reader.GetOrdinal("sprname"));
int desc = Convert.ToInt32(reader.GetString(reader.GetOrdinal("desc")));
if (!_skillTreeInfo.ContainsKey(maintype))
{
_skillTreeInfo[maintype] = new Dictionary <int, Dictionary <int, SkillTreeUnit> >();
}
if (!_skillTreeInfo[maintype].ContainsKey(skilltype))
{
_skillTreeInfo[maintype][skilltype] = new Dictionary <int, SkillTreeUnit>();
}
SkillTreeUnit info = new SkillTreeUnit();
info._id = id;
info._mainType = maintype;
info._skillType = skilltype;
info._skillGroup = skillgroup;
info._skillGrade = skillgrade;
info._level = level;
info._exp = exp;
info._parent = parent;
info._value = value;
info._sprName = sprName;
info._descIndex = desc;
info._desc = PELocalization.GetString(desc);
info.Parse(value);
_skillTreeInfo[maintype][skilltype][level] = info;
}
foreach (var iter in _skillTreeInfo)
{
foreach (var iter1 in iter.Value)
{
foreach (var iter2 in iter1.Value)
{
SkillTreeUnit unit = GetMaxLevelSkillByType(iter2.Value._skillType);
if (unit != null)
{
iter2.Value._maxLevel = unit._level;
}
}
}
}
LoadMainTypeData();
}
public void AddSkillUnit(SkillTreeUnit unit)
{
if (_learntSkills.Contains(unit))
{
return;
}
unit.RefreshBuff(_ske);
_learntSkills.Add(unit);
}
public SKTLearnResult SKTLearn(int skillType)
{
SkillTreeUnit skill = FindSkillUnit(skillType);
SkillTreeUnit nextSkill;
if (skill != null)
{
int nextLevel = skill._level + 1;
nextSkill = SkillTreeInfo.GetSkillUnit(skillType, nextLevel);
if (nextSkill != null)
{
SKTLearnResult result = CheckLevelUpCondition(nextSkill);
if (result != SKTLearnResult.SKTLearnResult_Success)
{
return(result);
}
if (!DecExp(nextSkill._exp))
{
return(SKTLearnResult.SKTLearnResult_DontHaveEnoughExp);
}
RemoveSkillUnit(skill);
AddSkillUnit(nextSkill);
}
else
{
return(SKTLearnResult.SKTLearnResult_DataError);
}
}
else
{
nextSkill = SkillTreeInfo.GetMinLevelSkillByType(skillType);
if (nextSkill != null)
{
SKTLearnResult result = CheckLevelUpCondition(nextSkill);
if (result != SKTLearnResult.SKTLearnResult_Success)
{
return(result);
}
if (!DecExp(nextSkill._exp))
{
return(SKTLearnResult.SKTLearnResult_DontHaveEnoughExp);
}
;
AddSkillUnit(nextSkill);
}
else
{
return(SKTLearnResult.SKTLearnResult_DataError);
}
}
SkillTreeInfo.RefreshUI(nextSkill._mainType);
if (GameConfig.IsMultiMode && _net != null)
{
_net.RPCServer(EPacketType.PT_InGame_SKTLevelUp, skillType, PlayerNetwork.mainPlayerId);
}
return(SKTLearnResult.SKTLearnResult_Success);
}
void RPC_S2C_InitLearntSkills(uLink.BitStream stream, uLink.NetworkMessageInfo info)
{
int[] ids = stream.Read <int[]>();
for (int i = 0; i < ids.Length; i++)
{
SkillTreeUnit skillUnit = SkillTreeInfo.GetSkillUnit(ids[i]);
if (skillUnit != null)
{
_learntSkills.AddSkillUnit(skillUnit);
}
}
_learntSkills.InitDefaultSkill();
}
public void ChangeSkillState(SkillTreeUnit skill)
{
skill._state = SkillState.Lock;
if (_learntSkills.Contains(skill))
{
skill._state = SkillState.learnt;
return;
}
string[] args = skill._parent.Split(';');
for (int i = 0; i < args.Length; i++)
{
SkillTreeUnit skillUnit = SkillTreeInfo.GetSkillUnit(System.Int32.Parse(args[i]));
if (skillUnit == null)
{
if (args[i] == "0")
{
skill._state = SkillState.unLock;
}
else
{
skill._state = SkillState.Lock;
Debug.LogError("parent skill is not exsit");
}
return;
}
else
{
SkillTreeUnit skilllearnt = FindSkillUnit(skillUnit._skillType);
if (skilllearnt != null)
{
if (skilllearnt._level >= skillUnit._level)
{
if (i == args.Length - 1)
{
skill._state = SkillState.unLock;
}
}
else
{
skill._state = SkillState.Lock;
return;
}
}
else
{
skill._state = SkillState.Lock;
return;
}
}
}
}
public static List <SkillTreeUnit> GetMinLevelByMainType(int mainType)
{
List <SkillTreeUnit> skills = new List <SkillTreeUnit>();
if (_skillTreeInfo.ContainsKey(mainType))
{
foreach (KeyValuePair <int, Dictionary <int, SkillTreeUnit> > kvp1 in _skillTreeInfo[mainType])
{
SkillTreeUnit unit = null;
foreach (KeyValuePair <int, SkillTreeUnit> item in kvp1.Value)
{
if (unit == null)
{
unit = item.Value;
}
if (unit != null && item.Value != null)
{
if (unit._level > item.Value._level)
{
unit = item.Value;
}
}
}
if (unit != null)
{
skills.Add(unit);
}
}
}
if (skills != null)
{
skills.Sort((left, right) =>
{
if (left._skillGrade > right._skillGrade)
{
return(1);
}
else if (left._skillGrade == right._skillGrade)
{
return(0);
}
else
{
return(-1);
}
});
}
return(skills);
}
SKTLearnResult CheckLevelUpCondition(SkillTreeUnit skill)
{
if (_ske == null)
{
return(SKTLearnResult.SKTLearnResult_SkAliveEntityIsNULL);
}
if (skill != null)
{
if (_ske.GetAttribute((int)AttribType.Exp) < skill._exp)
{
return(SKTLearnResult.SKTLearnResult_DontHaveEnoughExp);
}
if (skill._parent != "0")
{
string[] args = skill._parent.Split(';');
for (int i = 0; i < args.Length; i++)
{
SkillTreeUnit skillunit = SkillTreeInfo.GetSkillUnit(System.Int32.Parse(args[i]));
if (skillunit == null)
{
return(SKTLearnResult.SKTLearnResult_DataError);
}
else
{
SkillTreeUnit skilllearnt = FindSkillUnit(skillunit._skillType);
if (skilllearnt != null)
{
if (skilllearnt._level >= skillunit._level)
{
if (i == args.Length - 1)
{
return(SKTLearnResult.SKTLearnResult_Success);
}
}
else
{
return(SKTLearnResult.SKTLearnResult_NeedLearntParentSkill);
}
}
}
}
return(SKTLearnResult.SKTLearnResult_DataError);
}
return(SKTLearnResult.SKTLearnResult_Success);
}
return(SKTLearnResult.SKTLearnResult_DataError);
}
public override void Deserialize(BinaryReader _in)
{
if (_net != null)
{
return;
}
int count = _in.ReadInt32();
for (int i = 0; i < count; i++)
{
int id = _in.ReadInt32();
SkillTreeUnit skillUnit = SkillTreeInfo.GetSkillUnit(id);
if (skillUnit != null)
{
AddSkillUnit(skillUnit);
}
}
}
void RPC_S2C_SKTLevelUp(uLink.BitStream stream, uLink.NetworkMessageInfo info)
{
int levelUpType = stream.Read <int>();
int level = stream.Read <int> ();
int playerid = stream.Read <int> ();
if (playerid == PlayerNetwork.mainPlayerId || _learntSkills == null)
{
return;
}
SkillTreeUnit skillUnit = _learntSkills.FindSkillUnit(levelUpType);
if (skillUnit != null)
{
_learntSkills.RemoveSkillUnit(skillUnit);
}
SkillTreeUnit nextSkillUnit = SkillTreeInfo.GetSkillUnit(levelUpType, level);
if (nextSkillUnit != null)
{
_learntSkills.AddSkillUnit(nextSkillUnit);
}
}
public void RemoveSkillUnit(SkillTreeUnit unit)
{
_learntSkills.Remove(unit);
}
