VDH
643 lines
24 KiB
C#
643 lines
24 KiB
C#
using Animancer;
|
|
using CSNetwork;
|
|
using CSNetwork.GPDataType;
|
|
using ModelRenderer.Scripts.GameData;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Runtime.InteropServices;
|
|
|
|
namespace BrewMonster.Scripts.Skills
|
|
{
|
|
public class CECHostSkillModel
|
|
{
|
|
private static CECHostSkillModel instance;
|
|
public static CECHostSkillModel Instance
|
|
{
|
|
get
|
|
{
|
|
if (instance == null)
|
|
{
|
|
instance = new CECHostSkillModel();
|
|
}
|
|
return instance;
|
|
}
|
|
|
|
set => instance = value;
|
|
}
|
|
ElementSkill s = null;
|
|
Dictionary<int, ElementSkill> m_allProfSkills = new Dictionary<int, ElementSkill>();
|
|
Dictionary<int, List<int>> m_allRankProfSkills = new Dictionary<int, List<int>>();
|
|
private HashSet<int> m_allProfNPCs = new HashSet<int>();
|
|
private Dictionary<int, int> m_treeHeightMap = new Dictionary<int, int>();
|
|
private Dictionary<int, int> m_evilRootMap = new Dictionary<int, int>();
|
|
private Dictionary<int, int> m_godRootMap = new Dictionary<int, int>();
|
|
private Dictionary<int, int> m_baseRootMap = new Dictionary<int, int>();
|
|
private int m_skillLearnNPCNID;
|
|
private bool m_bInitialized;
|
|
private Octets m_npcListData;
|
|
|
|
/// <summary>
|
|
/// 获取当前职业的全部技能映射（阶位 -> 技能列表） / Get rank-to-skills map for current profession.
|
|
/// </summary>
|
|
public IReadOnlyDictionary<int, List<int>> GetAllRankProfSkills()
|
|
{
|
|
return m_allRankProfSkills;
|
|
}
|
|
public enumSkillLearnedState GetSkillLearnedState(int skillID)
|
|
{
|
|
CECSkill pSkill = CECGameRun.Instance.GetHostPlayer().GetNormalSkill(skillID);
|
|
if (pSkill != null)
|
|
{
|
|
if (pSkill.GetSkillLevel() < pSkill.GetMaxLevel())
|
|
{
|
|
return enumSkillLearnedState.SKILL_LEARNED;
|
|
}
|
|
else
|
|
{
|
|
return enumSkillLearnedState.SKILL_FULL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (ElementSkill.IsOverridden((uint)skillID))
|
|
{
|
|
return enumSkillLearnedState.SKILL_OVERRIDDEN;
|
|
}
|
|
else
|
|
{
|
|
return enumSkillLearnedState.SKILL_NOT_LEARNED;
|
|
}
|
|
}
|
|
}
|
|
public void Initialize()
|
|
{
|
|
// Çå¿ÕËùÓм¼ÄÜ£¬·ÀÖ¹ÒòΪ¶à¸ö½ÇÉ«µÇ¼µ¼ÖÂÖظ´¼ÓÔؼ¼ÄÜ
|
|
Release();
|
|
|
|
InitAllSkillsOfCurProf();
|
|
FindAllNPCsOfCurProf();
|
|
HashSet<int> rootSkills = GetRootSkillSet();
|
|
InitSkillTreeHeightMap(rootSkills);
|
|
InitSkillTreeRootMap(rootSkills);
|
|
|
|
m_bInitialized = true;
|
|
|
|
// ÖØд¦ÀíNPCLIST
|
|
ProcessServiceList();
|
|
}
|
|
public void ProcessServiceList()
|
|
{
|
|
if (m_npcListData == null)
|
|
{
|
|
BMLogger.LogWarning("CECHostSkillModel::ProcessServiceList, m_npcListData is null.");
|
|
return;
|
|
}
|
|
if (m_npcListData.Size > 0)
|
|
{
|
|
byte[] data = m_npcListData.RawBuffer;
|
|
int headerSize = Marshal.SizeOf(typeof(cmd_header));
|
|
|
|
int offset = headerSize;
|
|
int bodySize = m_npcListData.Size - offset;
|
|
byte[] bodyBytes = new byte[bodySize];
|
|
Buffer.BlockCopy(data, offset, bodyBytes, 0, bodySize);
|
|
|
|
cmd_scene_service_npc_list npcList = default;
|
|
npcList.count = GPDataTypeHelper.FromBytes<uint>(bodyBytes);
|
|
offset = sizeof(uint);
|
|
int NpcEntrySize = Marshal.SizeOf<cmd_scene_service_npc_list.NpcEntry>();
|
|
npcList.list = new cmd_scene_service_npc_list.NpcEntry[npcList.count];
|
|
|
|
for (int z = 0; z < npcList.count; z++)
|
|
{
|
|
npcList.list[z] = GPDataTypeHelper.FromBytes<cmd_scene_service_npc_list.NpcEntry>(bodyBytes, offset);
|
|
offset += NpcEntrySize;
|
|
}
|
|
|
|
int i;
|
|
for (i = 0; i < npcList.count; i++)
|
|
{
|
|
int tid = npcList.list[i].tid;
|
|
|
|
if (m_allProfNPCs.Contains(tid))
|
|
{
|
|
if (m_skillLearnNPCNID != npcList.list[i].nid)
|
|
{
|
|
m_skillLearnNPCNID = npcList.list[i].nid;
|
|
SetCurServiceSkills(tid);
|
|
var change = new CECSkillPanelChange(CECSkillPanelChange.enumChangeMask.CHANGE_SKILL_NPC, 0, 0);
|
|
//NotifyObservers(change);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (i == npcList.count && m_skillLearnNPCNID != 0)
|
|
{
|
|
m_skillLearnNPCNID = 0;
|
|
SetCurServiceSkills(0);
|
|
var change = new CECSkillPanelChange(CECSkillPanelChange.enumChangeMask.CHANGE_SKILL_NPC, 0, 0);
|
|
//NotifyObservers(change);
|
|
}
|
|
|
|
m_npcListData.Clear();
|
|
}
|
|
}
|
|
private readonly HashSet<int> m_curServiceSkills = new HashSet<int>();
|
|
public string GetSkillIcon(int skillID)
|
|
{
|
|
CECSkill skill = new CECSkill(skillID, 1);
|
|
return (skill.GetIconFile());
|
|
}
|
|
public void SetCurServiceSkills(int tid)
|
|
{
|
|
m_curServiceSkills.Clear();
|
|
if (tid == 0)
|
|
return;
|
|
|
|
var pDB = ElementDataManProvider.GetElementDataMan();
|
|
|
|
// Read NPC_ESSENCE from element data
|
|
DATA_TYPE dt = default;
|
|
var dataprt = pDB.get_data_ptr((uint)tid, ID_SPACE.ID_SPACE_ESSENCE, ref dt);
|
|
if (dataprt == null)
|
|
return;
|
|
var npcEssence = (NPC_ESSENCE)dataprt;
|
|
|
|
// Get skill service block from id_skill_service
|
|
var dataprt2 = pDB.get_data_ptr(npcEssence.id_skill_service, ID_SPACE.ID_SPACE_ESSENCE, ref dt);
|
|
if (dataprt2 == null)
|
|
return;
|
|
|
|
var skillService = (NPC_SKILL_SERVICE)dataprt2;
|
|
// Copy all non-zero skill ids into m_curServiceSkills
|
|
foreach (int skillId in skillService.id_skills)
|
|
{
|
|
if (skillId != 0)
|
|
m_curServiceSkills.Add(skillId);
|
|
}
|
|
}
|
|
public enumSkillFitLevelState GetSkillFitLevel(int skillID)
|
|
{
|
|
if (!m_allProfSkills.ContainsKey(skillID))
|
|
{
|
|
BMLogger.LogError("skillID not exist in m_allProfSkills");
|
|
return default;
|
|
}
|
|
int maxLevel = CECGameRun.Instance.GetHostPlayer().GetMaxLevelSofar();
|
|
int rank = CECGameRun.Instance.GetHostPlayer().GetBasicProps().iLevel2;
|
|
int realmLevel = CECGameRun.Instance.GetHostPlayer().GetRealmLevel();
|
|
|
|
return GetSkillFitLevel(skillID, maxLevel, rank, realmLevel);
|
|
}
|
|
enumSkillFitLevelState GetSkillFitLevel(int skillID, int maxLevel, int rank, int realmLevel)
|
|
{
|
|
if (!m_allProfSkills.ContainsKey(skillID))
|
|
{
|
|
BMLogger.LogError("skillID not exist in m_allProfSkills");
|
|
return default;
|
|
}
|
|
|
|
int skillLevel = 1; //½«ÒªÑ§Ï°µÄ¼¼Äܼ¶±ð
|
|
CECSkill pSkill = CECGameRun.Instance.GetHostPlayer().GetNormalSkill(skillID);
|
|
if (pSkill != null)
|
|
{
|
|
skillLevel = pSkill.GetSkillLevel() + 1;
|
|
if (skillLevel > pSkill.GetMaxLevel())
|
|
{
|
|
return enumSkillFitLevelState.SKILL_NOT_FIT_LEVEL;
|
|
}
|
|
}
|
|
|
|
s = ElementSkill.Create((uint)skillID, skillLevel);
|
|
|
|
if (s.GetRequiredLevel() > maxLevel)
|
|
{
|
|
return enumSkillFitLevelState.SKILL_NOT_FIT_LEVEL;
|
|
}
|
|
// ÐÞÕæµÈ¼¶²»¹»
|
|
CECTaoistRank curTaoistRank = CECTaoistRank.GetTaoistRank(rank);
|
|
CECTaoistRank reqTaoistRank = CECTaoistRank.GetTaoistRank(s.GetRank());
|
|
if ((curTaoistRank.IsEvilRank() && reqTaoistRank.IsGodRank()) ||
|
|
(curTaoistRank.IsGodRank() && reqTaoistRank.IsEvilRank()) ||
|
|
(curTaoistRank.GetID() < reqTaoistRank.GetID()))
|
|
{
|
|
return enumSkillFitLevelState.SKILL_NOT_FIT_LEVEL;
|
|
}
|
|
// ¾³½ç²»¹»
|
|
if (s.GetRequiredRealmLevel() > realmLevel)
|
|
{
|
|
return enumSkillFitLevelState.SKILL_NOT_FIT_LEVEL;
|
|
}
|
|
|
|
return enumSkillFitLevelState.SKILL_FIT_LEVEL;
|
|
}
|
|
public int CheckLearnCondition(int skillID)
|
|
{
|
|
return CECGameRun.Instance.GetHostPlayer().CheckSkillLearnCondition(skillID, true);
|
|
}
|
|
public int GetRequiredBook(int skillID, int level)
|
|
{
|
|
int itemId = ElementSkill.GetRequiredBook((uint)skillID, level);
|
|
return itemId;
|
|
}
|
|
public void RecvNPCServiceList(Octets Data)
|
|
{
|
|
m_npcListData = Data;
|
|
if (!m_bInitialized)
|
|
{
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
ProcessServiceList();
|
|
}
|
|
}
|
|
private void InitSkillTreeRootMap(IEnumerable<int> rootSkills)
|
|
{
|
|
foreach (int rootSkillID in rootSkills)
|
|
{
|
|
InitializeRootOfSkillTree(rootSkillID);
|
|
}
|
|
}
|
|
public int GetSkillCurrentLevel(int skillID)
|
|
{
|
|
if (!m_allProfSkills.ContainsKey(skillID))
|
|
{
|
|
BMLogger.LogError("skillID not exist in m_allProfSkills");
|
|
return 0;
|
|
}
|
|
|
|
CECSkill pSkill = CECGameRun.Instance.GetHostPlayer().GetNormalSkill(skillID);
|
|
if (pSkill != null)
|
|
{
|
|
return pSkill.GetSkillLevel();
|
|
}
|
|
else
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
private void InitializeRootOfSkillTree(int rootSkillID)
|
|
{
|
|
var skillRootMap = GetSkillRootMap(rootSkillID);
|
|
var toTravelSkills = new Queue<int>();
|
|
toTravelSkills.Enqueue(rootSkillID);
|
|
|
|
while (toTravelSkills.Count > 0)
|
|
{
|
|
int skillID = toTravelSkills.Dequeue();
|
|
var juniors = GetJunior(skillID);
|
|
|
|
foreach (var (id, level) in juniors)
|
|
{
|
|
int juniorSkillID = (int)id;
|
|
skillRootMap[juniorSkillID] = rootSkillID;
|
|
toTravelSkills.Enqueue(juniorSkillID);
|
|
}
|
|
}
|
|
}
|
|
private Dictionary<int, int> GetSkillRootMap(int rootSkillID)
|
|
{
|
|
var skill = m_allProfSkills[rootSkillID];
|
|
var taoistRank = CECTaoistRank.GetTaoistRank(skill.GetRank());
|
|
|
|
if (taoistRank.IsEvilRank())
|
|
return m_evilRootMap;
|
|
else if (taoistRank.IsGodRank())
|
|
return m_godRootMap;
|
|
else
|
|
return m_baseRootMap;
|
|
}
|
|
|
|
private void InitSkillTreeHeightMap(IEnumerable<int> rootSkills)
|
|
{
|
|
foreach (var rootSkillID in rootSkills)
|
|
{
|
|
m_treeHeightMap[rootSkillID] = GetSkillTreeHeight(rootSkillID);
|
|
}
|
|
}
|
|
private int GetSkillTreeHeight(int rootSkillID)
|
|
{
|
|
var juniors = GetJunior(rootSkillID);
|
|
int maxHeight = 0;
|
|
|
|
for (int i = 0; i < juniors.Count; i++)
|
|
{
|
|
int subHeight = GetSkillTreeHeight((int)juniors[i].id);
|
|
if (subHeight > maxHeight)
|
|
{
|
|
maxHeight = subHeight;
|
|
}
|
|
}
|
|
|
|
return 1 + maxHeight;
|
|
}
|
|
private List<(uint id, int level)> GetJunior(int skillID)
|
|
{
|
|
if (!m_allProfSkills.TryGetValue(skillID, out var skill))
|
|
{
|
|
BMLogger.LogError($"Skill {skillID} not found in m_allProfSkills");
|
|
}
|
|
|
|
var juniors = skill.GetJunior();
|
|
var ret = new List<(uint id, int level)>();
|
|
|
|
foreach (var (id, level) in juniors)
|
|
{
|
|
if (id != 0)
|
|
ret.Add((id, level));
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
private HashSet<int> GetRootSkillSet()
|
|
{
|
|
var rootSkills = new HashSet<int>();
|
|
|
|
foreach (var kvp in m_allProfSkills)
|
|
if (kvp.Value.GetJunior().Count != 0)
|
|
rootSkills.Add(kvp.Key);
|
|
|
|
foreach (var kvp in m_allProfSkills)
|
|
foreach (var (id, level) in kvp.Value.GetJunior())
|
|
rootSkills.Remove((int)id);
|
|
|
|
return rootSkills;
|
|
}
|
|
private void FindAllNPCsOfCurProf()
|
|
{
|
|
DATA_TYPE dt = DATA_TYPE.DT_NPC_ESSENCE;
|
|
elementdataman pDB = ElementDataManProvider.GetElementDataMan();
|
|
var map = pDB.GetAllDataTypeWithType(ID_SPACE.ID_SPACE_ESSENCE, dt);
|
|
foreach (var obj in map)
|
|
{
|
|
NPC_ESSENCE npcEssence = (NPC_ESSENCE)obj;
|
|
if (npcEssence.id_skill_service != 0 &&
|
|
(npcEssence.combined_switch & (uint)NPC_COMBINED_SWITCH.NCS_IGNORE_DISTANCE_CHECK) != 0)
|
|
{
|
|
NPC_SKILL_SERVICE skillService = (NPC_SKILL_SERVICE)pDB.get_data_ptr(npcEssence.id_skill_service, ID_SPACE.ID_SPACE_ESSENCE, ref dt);
|
|
bool profCorrect = false;
|
|
for (int i = 0; i < skillService.id_skills.Length; i++)
|
|
{
|
|
if (skillService.id_skills[i] != 0)
|
|
{
|
|
ElementSkill pSkill = ElementSkill.Create(skillService.id_skills[i], 1);
|
|
|
|
if (pSkill == null) return;
|
|
|
|
if (pSkill.GetCls() == CECGameRun.Instance.GetHostPlayer().GetProfession())
|
|
{
|
|
// ��NPC������ǰְҵ���ܣ���Ҫ��¼��NPC��ID
|
|
profCorrect = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (profCorrect)
|
|
{
|
|
m_allProfNPCs.Add((int)npcEssence.id);
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
public void InitAllSkillsOfCurProf()
|
|
{
|
|
// --- B1: Thu thập toàn bộ skill từ các NPC có cung cấp dịch vụ học skill ---
|
|
HashSet<uint> npcSkills = new HashSet<uint>();
|
|
{
|
|
elementdataman pDB = ElementDataManProvider.GetElementDataMan();
|
|
DATA_TYPE dt = DATA_TYPE.DT_NPC_ESSENCE;
|
|
// uint id = pDB.get_id_with_data_type(ID_SPACE.ID_SPACE_ESSENCE, dt);
|
|
var map = pDB.GetAllDataTypeWithType(ID_SPACE.ID_SPACE_ESSENCE, dt);
|
|
foreach (var obj in map)
|
|
{
|
|
NPC_ESSENCE npcEssence = (NPC_ESSENCE)obj;
|
|
if (npcEssence.id_skill_service != 0 &&
|
|
(npcEssence.combined_switch & (uint)NPC_COMBINED_SWITCH.NCS_IGNORE_DISTANCE_CHECK) != 0)
|
|
{
|
|
NPC_SKILL_SERVICE skillService = (NPC_SKILL_SERVICE)pDB.get_data_ptr(
|
|
npcEssence.id_skill_service, ID_SPACE.ID_SPACE_ESSENCE, ref dt
|
|
);
|
|
|
|
for (int i = 0; i < skillService.id_skills.Length; i++)
|
|
{
|
|
uint skillId = skillService.id_skills[i];
|
|
if (skillId != 0 &&
|
|
CECComboSkillState.Instance.GetInherentSkillByID(skillId) == null)
|
|
{
|
|
npcSkills.Add(skillId);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// --- B2: Duyệt tất cả skill, lọc skill theo class hiện tại của người chơi ---
|
|
uint curID = 0;
|
|
while ((curID = ElementSkill.NextSkill(curID)) != 0)
|
|
{
|
|
ElementSkill pSkill = ElementSkill.Create(curID, 1);
|
|
int cls = pSkill.GetCls();
|
|
int playerCls = CECGameRun.Instance.GetHostPlayer().GetProfession();
|
|
|
|
bool isSameClass = (cls == playerCls || cls == 255);
|
|
bool isProvidedByNPC = npcSkills.Contains(curID);
|
|
|
|
if (isSameClass && isProvidedByNPC)
|
|
{
|
|
m_allProfSkills[(int)curID] = pSkill;
|
|
if (!m_allRankProfSkills.ContainsKey(pSkill.GetRank()))
|
|
m_allRankProfSkills[pSkill.GetRank()] = new List<int>();
|
|
m_allRankProfSkills[pSkill.GetRank()].Add((int)curID);
|
|
}
|
|
}
|
|
BMLogger.LogError("CECHostSkillModel::InitAllSkillsOfCurProf: total prof skills = " + m_allRankProfSkills.Count);
|
|
// --- B3: Sắp xếp skill trong từng rank theo thứ tự hiển thị ---
|
|
foreach (var kvp in m_allRankProfSkills)
|
|
{
|
|
kvp.Value.Sort((lhs, rhs) =>
|
|
{
|
|
var lSkill = ElementSkill.Create((uint)lhs, 1);
|
|
var rSkill = ElementSkill.Create((uint)rhs, 1);
|
|
|
|
bool result;
|
|
if (lSkill.GetType() == (byte)skill_type.TYPE_PASSIVE &&
|
|
rSkill.GetType() != (byte)skill_type.TYPE_PASSIVE)
|
|
{
|
|
result = false;
|
|
}
|
|
else if (lSkill.GetType() != (byte)skill_type.TYPE_PASSIVE &&
|
|
rSkill.GetType() == (byte)skill_type.TYPE_PASSIVE)
|
|
{
|
|
result = true;
|
|
}
|
|
else
|
|
{
|
|
result = lSkill.GetShowOrder() < rSkill.GetShowOrder();
|
|
}
|
|
|
|
return result ? -1 : 1;
|
|
});
|
|
}
|
|
}
|
|
|
|
|
|
private void Release()
|
|
{
|
|
m_allProfSkills.Clear();
|
|
|
|
// Dọn sạch tất cả dictionary / map
|
|
m_allProfSkills.Clear();
|
|
m_allRankProfSkills.Clear();
|
|
|
|
m_evilRootMap.Clear();
|
|
m_godRootMap.Clear();
|
|
m_baseRootMap.Clear();
|
|
m_treeHeightMap.Clear();
|
|
|
|
m_allProfNPCs.Clear();
|
|
m_curServiceSkills.Clear();
|
|
|
|
m_skillLearnNPCNID = 0;
|
|
m_bInitialized = false;
|
|
}
|
|
public string GetSkillName(int skillID)
|
|
{
|
|
CECSkill skill = new CECSkill(skillID, 1);
|
|
return (skill.GetNameDisplay());
|
|
}
|
|
public bool CheckPreItem(int itemID)
|
|
{
|
|
return CECGameRun.Instance.GetHostPlayer().GetPack().FindItem(itemID) != -1;
|
|
}
|
|
public bool IsSkillServedByNPC(int skillID)
|
|
{
|
|
return m_curServiceSkills.Contains(skillID);
|
|
}
|
|
public int GetSkillSp(int skillID, int level)
|
|
{
|
|
if (!m_allProfSkills.ContainsKey(skillID))
|
|
{
|
|
BMLogger.LogError("skillID not exist in m_allProfSkills");
|
|
return 0;
|
|
}
|
|
|
|
return ElementSkill.GetRequiredSp((uint)skillID, level);
|
|
}
|
|
public int GetSkillMoney(int skillID, int level)
|
|
{
|
|
if (!m_allProfSkills.ContainsKey(skillID))
|
|
{
|
|
BMLogger.LogError("skillID not exist in m_allProfSkills");
|
|
return 0;
|
|
}
|
|
|
|
return ElementSkill.GetRequiredMoney((uint)skillID, level);
|
|
}
|
|
public Dictionary<uint, int> GetRequiredSkill(int skillID, int level)
|
|
{
|
|
Dictionary<uint, int> requiredSkill = new();
|
|
|
|
ElementSkill s = ElementSkill.Create((uint)skillID, level);
|
|
// giả định GetRequiredSkill() trả về List<KeyValuePair<uint,int>> hoặc IReadOnlyList<...>
|
|
Dictionary<uint, int> skills = s.GetRequiredSkill();
|
|
if (skills == null || skills.Count == 0)
|
|
return null;
|
|
foreach (var skill in skills)
|
|
{
|
|
if (skill.Key != 0)
|
|
{
|
|
requiredSkill.Add(skill.Key, skill.Value);
|
|
}
|
|
}
|
|
|
|
return requiredSkill;
|
|
}
|
|
public bool CheckPreSkillLevel(int skillID, int level)
|
|
{
|
|
if (GetSkillLearnedState(skillID) == enumSkillLearnedState.SKILL_OVERRIDDEN)
|
|
{
|
|
// Èç¹û¸ÃÇ°Ìá¼¼Äܱ»¸²¸Ç£¬ÔòÇ°Ìá¼¼ÄÜÒ»¶¨Âú×ã
|
|
return true;
|
|
}
|
|
return GetSkillCurrentLevel(skillID) >= level;
|
|
}
|
|
|
|
// Called when a skill is learned / 当学习新技能后调用
|
|
public void OnLearnSkill(int skillID, int skillLevel)
|
|
{
|
|
if (!m_allProfSkills.ContainsKey(skillID))
|
|
{
|
|
return;
|
|
}
|
|
|
|
// 检查学习新技能后是否有技能被覆盖 / Check if any skills are overridden after learning the new skill
|
|
bool newOverridden = false;
|
|
var juniors = GetJunior(skillID);
|
|
if (juniors.Count > 0)
|
|
{
|
|
newOverridden = true;
|
|
}
|
|
|
|
if (newOverridden)
|
|
{
|
|
CECSkillPanelChange change = new CECSkillPanelChange(
|
|
CECSkillPanelChange.enumChangeMask.CHANGE_SKILL_OVERRIDDEN,
|
|
skillID,
|
|
skillLevel);
|
|
EventBus.Publish(change);
|
|
}
|
|
else
|
|
{
|
|
CECSkillPanelChange change = new CECSkillPanelChange(
|
|
CECSkillPanelChange.enumChangeMask.CHANGE_SKILL_LEVEL_UP,
|
|
skillID,
|
|
skillLevel);
|
|
EventBus.Publish(change);
|
|
}
|
|
}
|
|
}
|
|
|
|
public enum enumSkillFitLevelState
|
|
{
|
|
SKILL_FIT_LEVEL, // ��������ȼ������桢�������� / Skill meets level, cultivation, realm requirements
|
|
SKILL_NOT_FIT_LEVEL, // ���ܲ�����ȼ������桢�������� / Skill does not meet level, cultivation, realm requirements
|
|
}
|
|
|
|
public enum enumSkillLearnedState
|
|
{
|
|
SKILL_NOT_LEARNED, // ����δѧϰ / Skill not learned
|
|
SKILL_LEARNED, // ������ѧϰ���������� / Skill learned but not at max level
|
|
SKILL_FULL, // ���������� / Skill at max level
|
|
SKILL_OVERRIDDEN, // �����ѱ����� / Skill has been overridden
|
|
}
|
|
|
|
public enum enumEvilGod
|
|
{
|
|
SKILL_BASE, // ��ͨ���� / Normal skill
|
|
SKILL_EVIL, // �ɼ��� / Immortal skill
|
|
SKILL_GOD, // ħ���� / Demonic skill
|
|
}
|
|
public struct CECSkillPanelChange
|
|
{
|
|
public enum enumChangeMask
|
|
{
|
|
CHANGE_SKILL_LEVEL_UP, // Skill level up
|
|
CHANGE_SKILL_OVERRIDDEN, // Skill overridden
|
|
CHANGE_SKILL_NPC // NPC providing skill changed
|
|
}
|
|
|
|
public enumChangeMask m_changeMask;
|
|
public int m_skillID;
|
|
public int m_skillLevel;
|
|
|
|
public CECSkillPanelChange(enumChangeMask mask, int id, int level)
|
|
{
|
|
m_changeMask = mask;
|
|
m_skillID = id;
|
|
m_skillLevel = level;
|
|
}
|
|
}
|
|
} |