/// <summary>
/// 检查技能前置条件
/// </summary>
/// <param name="enumSkillType"></param>
/// <returns></returns>
private bool CheckSkillPrecondition(EnumSkillType enumSkillType)
{
SkillBaseStruct skillBaseStruct = skillStructData.SearchSkillDatas(temp => temp.skillType == enumSkillType).FirstOrDefault();
if (skillBaseStruct != null)
{
//需求技能组的加点
KeyValuePair <EnumSkillZone, int>[] skillMustZoneDic = skillBaseStruct.skillPrecondition.mustSkillZonePointDic.OfType <KeyValuePair <EnumSkillZone, int> >().ToArray();
foreach (var item in skillMustZoneDic)
{
int nowZonePoint = 0;
zonePointDic.TryGetValue(item.Key, out nowZonePoint); //当前组的加点
if (nowZonePoint < item.Value) //如果当前的组加点小于必需的组加点
{
return(false);
}
}
//需求前置技能的加点
KeyValuePair <EnumSkillType, int>[] skillMustTypeDic = skillBaseStruct.skillPrecondition.mustSkillPointDic.OfType <KeyValuePair <EnumSkillType, int> >().ToArray();
foreach (var item in skillMustTypeDic)
{
int nowSkillPoint = 0;
skillPointDic.TryGetValue(item.Key, out nowSkillPoint); //当前的技能加点
if (nowSkillPoint < item.Value) //如果当前的加点小于必须的加点
{
return(false);
}
}
return(true);
}
return(false);
}
/// <summary>
/// 添加一个技能到运行时栏位
/// </summary>
/// <param name="skillEnum">技能</param>
/// <returns></returns>
public bool SetSkill(int skillEnum)
{
var skillStructData = DataCenter.Instance.GetMetaData <SkillStructData>();
if (skillEnum > combineBaseNum)
{
int skill1Num = skillEnum % 100 + 1000; skillEnum /= 100;
int skill2Num = skillEnum % 100 + 1100; skillEnum /= 100;
int skill3Num = skillEnum & 100 + 1200; skillEnum /= 100;
int skill4Num = skillEnum % 100 + 1300; skillEnum /= 100;
SkillBaseStruct[] addSkillBaseStructArray = (new[] { skill1Num, skill2Num, skill3Num, skill4Num })
.Select(temp => (EnumSkillType)temp)
.Select(temp => skillStructData.SearchSkillDatas(temp1 => temp1.skillType == temp).FirstOrDefault())
.Where(temp => temp != null)
.ToArray();
List <SkillBaseStruct> tempSkillBaseStruct = new List <SkillBaseStruct>(skillBaseStructList.ToArray());
tempSkillBaseStruct.AddRange(addSkillBaseStructArray);
bool result = SkillCombinDisk.Intance.GetCanCombinSkill(tempSkillBaseStruct.ToArray());
skillBaseStructList.AddRange(addSkillBaseStructArray);
return(result);
}
else if (skillEnum > (int)EnumSkillType.MagicCombinedLevel1Start && skillEnum < (int)EnumSkillType.MagicCombinedLevel4End)
{
List <SkillBaseStruct> tempSkillBaseStruct = new List <SkillBaseStruct>(skillBaseStructList.ToArray());
SkillBaseStruct skillBaseStruct = skillStructData.SearchSkillDatas(temp => temp.skillType == (EnumSkillType)skillEnum).FirstOrDefault();
tempSkillBaseStruct.Add(skillBaseStruct);
bool result = SkillCombinDisk.Intance.GetCanCombinSkill(tempSkillBaseStruct.ToArray());
skillBaseStructList.Add(skillBaseStruct);
return(result);
}
return(false);
}
/// <summary>
/// 获取指定技能的下一阶段可组合技能
/// </summary>
/// <param name="fromSkill"></param>
/// <returns></returns>
public SkillBaseStruct[] GetNextSkill(params SkillBaseStruct[] fromSkill)
{
var skillStructData = DataCenter.Instance.GetMetaData <SkillStructData>();
if (fromSkill.Length == 0)
{
return(skillStructData.SearchSkillDatas(temp => temp.skillType > EnumSkillType.MagicCombinedLevel1Start && temp.skillType < EnumSkillType.MagicCombinedLevel1End));
}
if (fromSkill.Length == 1)
{
SkillBaseStruct skill1 = fromSkill[0];
SkillBaseStruct[] skills2 = skillStructData.SearchSkillDatas(temp => temp.skillType > EnumSkillType.MagicCombinedLevel2Start && temp.skillType < EnumSkillType.MagicCombinedLevel2End);
skills2 = skills2.Where(temp => GetCanCombinSkill(skill1, temp)).ToArray();
return(skills2);
}
if (fromSkill.Length == 2)
{
SkillBaseStruct skill1 = fromSkill[0];
SkillBaseStruct skill2 = fromSkill[1];
SkillBaseStruct[] skills3 = skillStructData.SearchSkillDatas(temp => temp.skillType > EnumSkillType.MagicCombinedLevel3Start && temp.skillType < EnumSkillType.MagicCombinedLevel3End);
skills3 = skills3.Where(temp => GetCanCombinSkill(skill1, skill2, temp)).ToArray();
return(skills3);
}
if (fromSkill.Length == 3)
{
SkillBaseStruct skill1 = fromSkill[0];
SkillBaseStruct skill2 = fromSkill[1];
SkillBaseStruct skill3 = fromSkill[2];
SkillBaseStruct[] skills4 = skillStructData.SearchSkillDatas(temp => temp.skillType > EnumSkillType.MagicCombinedLevel4Start && temp.skillType < EnumSkillType.MagicCombinedLevel4End);
skills4 = skills4.Where(temp => GetCanCombinSkill(skill1, skill2, skill3, temp)).ToArray();
return(skills4);
}
return(new SkillBaseStruct[0]);
}
public SpecialSkillStateStruct(EnumSkillType skillType, bool isOpen, int skillLevel, SkillBaseStruct skillBaseStruct, Action <SpecialSkillStateStruct> ChangeCallback)
{
this._skillType = skillType;
this._isOpen = isOpen;
this._skillLevel = skillLevel;
this._skillBaseStruct = skillBaseStruct;
this._ChangeCallback = ChangeCallback;
}
/// <summary>
/// 直接释放技能
/// </summary>
/// <param name="skillBaseStruct">直接释放技能</param>
public void DirectReleaseSkill(SkillBaseStruct skillBaseStruct)
{
//检测当前状态，是否正在释放读条技能，并且处于非被控制状态
if (true && skillBaseStructs == null)
{
//释放技能
//-------------------
//技能动作
//-------------------
}
}
/// <summary>
/// 检查技能的加按钮是否可以使用
/// </summary>
/// <param name="enumSkillType"></param>
/// <returns></returns>
private bool CheckMaxHandleCanUse(EnumSkillType enumSkillType)
{
int oldPoint;
SkillBaseStruct skillBaseStruct = skillStructData.SearchSkillDatas(temp => temp.skillType == enumSkillType).FirstOrDefault();
if (playerState.SkillPoint.TryGetValue(enumSkillType, out oldPoint) && skillBaseStruct != null)
{
if (uiAddNum.Value >= skillBaseStruct.maxLevel)//技能如果已经到达最大了,则不能再加了
{
return(false);
}
if (playerState.FreedomPoint <= tempUseSkillPoint)//如果剩余技能点已经全部被使用,则不能再加了
{
return(false);
}
return(true);
}
return(false);
}
/// <summary>
/// 根据当前的技能框项显示技能选择
/// </summary>
private void SetSelectSkill()
{
uiSelectSkillList.gameObject.SetActive(true);
//根据当前的技能框，选择技能的种类来初始化技能选择集合并显示该集合
uiSelectSkillList.Init();
//需要选中的技能框以及已经存放的技能显示可以放入的技能
//当前的技能组合
EnumSkillType[] nowSkillCombineTypes = (nowCombineSkillItem.value as EnumSkillType[]).Clone() as EnumSkillType[];
//判断当前锁定框的位置
int level = nowUISkilCombineLattice.Level;
//通过位置和判断是否可以组合技能显示需要添加的技能
EnumSkillType[] canSetSkillTypes = SkillCombineStaticTools.GetBaseSkillBackCombineSkillIndex(level); //该阶段的技能
EnumSkillType[] addedPointSkillTypes = playerState.SkillPoint.Where(temp => temp.Value > 0).Select(temp => temp.Key).ToArray(); //所有加点的技能
List <EnumSkillType> mustShowSkillTypes = canSetSkillTypes.Intersect(addedPointSkillTypes).ToList(); //简略判断可以显示的技能
//将现有技能组合判断是否可以使用技能
mustShowSkillTypes.RemoveAll(temp =>
{
nowSkillCombineTypes[level - 1] = temp;
return(!SkillCombineStaticTools.GetCanCombineSkills(nowSkillCombineTypes));
});
mustShowSkillTypes.Insert(0, EnumSkillType.None);//第一个必须是None技能
foreach (EnumSkillType mustShowSkillType in mustShowSkillTypes)
{
UIListItem uiListItem = uiSelectSkillList.NewItem();
SkillBaseStruct tempSkillBaseStruct = skillStructData_Base.SearchSkillDatas(temp => temp.skillType == mustShowSkillType).FirstOrDefault();
//uiListItem.childImage.sprite = tempSkillBaseStruct == null ? null : tempSkillBaseStruct.skillSprite;
uiListItem.value = mustShowSkillType;
uiListItem.childText.text = SkillCombineStaticTools.GetSingleSkillName(mustShowSkillType);
}
uiSelectSkillList.UpdateUI();
//设置第一个技能高亮
nowSelectSkillItem = uiSelectSkillList.FirstShowItem();
if (nowSelectSkillItem)
{
nowSelectSkillItem.childImage.gameObject.SetActive(true);
nowSelectSkillItem.childImage.enabled = true;
}
//然后切换状态到技能选择
enumUISkillCombine = EnumUISkillCombine.CombineSkillSelect;
}
/// <summary>
/// 根据指定的类型和id设置图标
/// </summary>
public void InitShow()
{
switch (keyLatticeType)
{
case EnumKeyContactType.Skill:
if (ThisSkillStructData == null)
{
break;
}
if (id > (int)EnumSkillType.MagicCombinedStart) //组合技能
{
SetTargetImage(SkillCombineStaticTools.GetCombineSkillSprite(ThisSkillStructData, id));
}
else //单一的技能
{
SkillBaseStruct skillBaseStruct = ThisSkillStructData.SearchSkillDatas(temp => temp.skillType == (EnumSkillType)id).FirstOrDefault();
if (skillBaseStruct != null)
{
SetTargetImage(skillBaseStruct.skillSprite);
}
else
{
SetTargetImage(null);
}
}
break;
case EnumKeyContactType.Prap:
if (ThisPlayerState == null)
{
break;
}
PlayGoods playGoods = ThisPlayerState.PlayerAllGoods.Where(temp => temp.ID == id).FirstOrDefault();
SetTargetImage(playGoods.GetGoodsSprite);
break;
default:
SetTargetImage(null);
break;
}
}
/// <summary>
/// 检查技能的减按钮是否可以使用
/// </summary>
/// <param name="enumSkillType"></param>
/// <returns></returns>
private bool CheckMinHandleCanUse(EnumSkillType enumSkillType)
{
int oldPoint;
if (playerState.SkillPoint.TryGetValue(enumSkillType, out oldPoint))
{
//if (oldPoint <= 0)//技能如果已经小于等于0了,则不能在减了
if (uiAddNum.Value <= 0)
{
return(false);
}
if (uiAddNum.Value <= oldPoint)//如果技能小于等于之前的加点数据,则不能再减了
{
return(false);
}
if (uiAddNum.Value == 1)//需要判断如果该技能等0(减去1后)时,是否会影响后置技能(组加点以及前置加点)
{
SkillBaseStruct skillBaseStruct = skillStructData.SearchSkillDatas(temp => temp.skillType == enumSkillType).FirstOrDefault();
if (skillBaseStruct != null)
{
EnumSkillZone[] skillZones = skillBaseStruct.skillZones;//当前技能所在的组数组
foreach (EnumSkillZone skillZone in skillZones)
{
int nowSkillZonePoint = 0;
zonePointDic.TryGetValue(skillZone, out nowSkillZonePoint); //获取当前技能组的点数
int mustSkillZonePoint = 0;
zoneMustPointDic.TryGetValue(skillZone, out mustSkillZonePoint); //获取需求技能组的点数
if (mustSkillZonePoint >= nowSkillZonePoint)
{
return(false);
}
}
return(true);
}
return(false);
}
return(true);
}
return(false);
}
/// <summary>
/// 初始化显示
/// </summary>
/// <param name="UpdatePreconditionStateAction">更新组加点状态(使用的是临时的加点状态计算的)</param>
public void InitSkillShow(Action UpdatePreconditionStateAction)
{
this.UpdatePreconditionStateAction = UpdatePreconditionStateAction;
playerState = DataCenter.Instance.GetEntity <PlayerState>();
skillStructData = DataCenter.Instance.GetMetaData <SkillStructData>();
EnumSkillType enumSkillType = (EnumSkillType)skillID;
if (uiAddNum)
{
//设置UI显示
//设置技能等级范围
SkillBaseStruct skillBaseStruct = skillStructData.SearchSkillDatas(temp => temp.skillType == enumSkillType).FirstOrDefault();
if (skillBaseStruct != null)
{
uiAddNum.Min = 0;
uiAddNum.Max = skillBaseStruct.maxLevel;
}
//设置当前的技能等级
int skillPoint;
if (playerState.SkillPoint.TryGetValue(enumSkillType, out skillPoint))
{
uiAddNum.Value = skillPoint;
}
else
{
uiAddNum.Value = 0;
}
//设置技能显示的图片
if (ShowSkillImage && skillBaseStruct != null)
{
ShowSkillImage.sprite = skillBaseStruct.skillSprite;
}
else
{
Debug.Log(enumSkillType + " " + transform.name);
}
}
}
/// <summary>
/// 从文件读取技能结构数据
/// </summary>
/// <param name="must">是否必须读取</param>
public void ReadSkillStructData(bool must = false)
{
if (skillBaseStructs == null || must)
{
TextAsset skillPathTextAsset = Resources.Load <TextAsset>("Data/Skill/Skills");
if (skillPathTextAsset == null)
{
skillBaseStructs = new SkillBaseStruct[0];
}
else
{
//获取其他类型的宏定义
Type edfineType = typeof(SkillStructConstString);
FieldInfo[] edfineInfos = edfineType.GetFields(BindingFlags.Static | BindingFlags.Public | BindingFlags.FlattenHierarchy);
Dictionary <string, string> edfineNameToValueDic = edfineInfos.ToDictionary(
temp => temp.Name,
temp => (string)temp.GetValue(null));
string[] otherSplit = new string[] { "***" };//截取其他数据时所用的分隔符
string[] splits = new string[] { "^^^" };
string[] skillPaths = skillPathTextAsset.text.Split(new string[] { "\r", "\n" }, StringSplitOptions.RemoveEmptyEntries)
.Select(temp => temp.Split(splits, StringSplitOptions.RemoveEmptyEntries))
.Where(temp => temp != null && temp.Length == 3)
.Select(temp => temp[2]).ToArray();
string[] skillValues = skillPaths
.Select(temp => Resources.Load <TextAsset>("Data/Skill/" + temp))
.Where(temp => temp != null)
.Select(temp => temp.text)
.ToArray();
skillAnalysisData.AnalysisData(skillValues);
string[] ids = skillAnalysisData.GetIDArray();
skillBaseStructs = new SkillBaseStruct[ids.Length];
for (int i = 0; i < ids.Length; i++)
{
string id = ids[i];
EnumSkillType enumSkillType = skillAnalysisData.GetEnum <EnumSkillType>(id, "skillType");
SkillBaseStruct skillBaseStruct = null;
Type newType = null;
//尝试使用该类型构造一个新的类
try
{
newType = Type.GetType("SkillStruct_" + enumSkillType.ToString());
skillBaseStruct = Activator.CreateInstance(newType) as SkillBaseStruct;
}
catch { }
if (skillBaseStruct == null)
{
skillBaseStruct = new SkillBaseStruct();
}
//加载其他属性
if (newType != null)
{
FieldInfo[] otherFieldInfos = newType.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
foreach (FieldInfo otherFieldInfo in otherFieldInfos)
{
string otherFieldName = otherFieldInfo.Name;
if (edfineNameToValueDic.ContainsKey(otherFieldName))
{
string otherFieldKey = edfineNameToValueDic[otherFieldName];
int[] otherFieldValues = skillAnalysisData.GetValues <int>(id, otherFieldKey);
if (otherFieldValues != null && otherFieldValues.Length > 0)
{
otherFieldInfo.SetValue(skillBaseStruct, otherFieldValues[0]);
}
}
}
}
//加载常规属性
skillBaseStructs[i] = skillBaseStruct;
skillBaseStruct.id = id;
skillBaseStruct.name = skillAnalysisData.GetValue <string>(id, "skillName");
skillBaseStruct.skillType = enumSkillType;
skillBaseStruct.skillMode = skillAnalysisData.GetEnum <EnumReleaseMode>(id, "releaseMode");
skillBaseStruct.skillZones = skillAnalysisData.GetEnums <EnumSkillZone>(id, "correlationZone").Where(temp => temp != EnumSkillZone.None).ToArray();
//加载技能图标
skillBaseStruct.skillSprite = SkillSpriteData.GetSprite(skillBaseStruct.skillType);
skillBaseStruct.skillSprite_Combine = SkillSpriteData.GetSpriteCombine(skillBaseStruct.skillType);
//计算技能名(现在暂定使用元名字)
skillBaseStruct.skillName = skillBaseStruct.name;
//完成加载特殊效果
skillBaseStruct.skillBelief = skillAnalysisData.GetEnum <EnumSkillBelief>(id, "skillBelief");
string[] skillStatusEffectStrs = skillAnalysisData.GetValues <string>(id, "skillStatusEffect").Where(temp => !string.IsNullOrEmpty(temp)).ToArray();
skillBaseStruct.skillStatusEffect = new EnumStatusEffect[skillStatusEffectStrs.Length];
for (int j = 0; j < skillStatusEffectStrs.Length; j++)
{
skillBaseStruct.skillStatusEffect[j] = (EnumStatusEffect)Enum.Parse(typeof(EnumStatusEffect), skillStatusEffectStrs[j]);
}
//技能前置
skillBaseStruct.skillPrecondition = new SkillPrecondition();
skillBaseStruct.skillPrecondition.mustSkillZonePointDic = new Dictionary <EnumSkillZone, int>();
skillBaseStruct.skillPrecondition.mustSkillPointDic = new Dictionary <EnumSkillType, int>();
EnumSkillZone[] preconditionSkillZones = skillAnalysisData.GetEnums <EnumSkillZone>(id, "correlationBeforeZone"); //前置技能组数组
int[] preconditionSkillZoneNums = skillAnalysisData.GetValues <int>(id, "correlationBeforeZoneCount"); //前置技能组加点
int preconditionSkillZoneCount = preconditionSkillZones.Length < preconditionSkillZoneNums.Length ? preconditionSkillZones.Length : preconditionSkillZoneNums.Length;
for (int j = 0; j < preconditionSkillZoneCount; j++)
{
if (preconditionSkillZones[j] != EnumSkillZone.None)
{
skillBaseStruct.skillPrecondition.mustSkillZonePointDic.Add(preconditionSkillZones[j], preconditionSkillZoneNums[j]);
}
}
EnumSkillType[] preconditionSkills = skillAnalysisData.GetEnums <EnumSkillType>(id, "correlationBeforeSkill"); //前置技能数组
int[] preconditionSkillNums = skillAnalysisData.GetValues <int>(id, "correlationBeforeSkillCount"); //前置技能加点
int preconditionSkillCount = preconditionSkillZones.Length < preconditionSkillNums.Length ? preconditionSkillZones.Length : preconditionSkillNums.Length;
for (int j = 0; j < preconditionSkillCount; j++)
{
if (preconditionSkills[j] != EnumSkillType.None)
{
skillBaseStruct.skillPrecondition.mustSkillPointDic.Add(preconditionSkills[j], preconditionSkillNums[j]);
}
}
//技能的技能等级以及属性
skillBaseStruct.maxLevel = skillAnalysisData.GetValue <int>(id, "skillLevel");
skillBaseStruct.skillAttributeStructs = new SkillAttributeStruct[skillBaseStruct.maxLevel];
Dictionary <string, Array> skillAttributeStructDic = new Dictionary <string, Array>();
Type skillAttributeStructType = typeof(SkillAttributeStruct);
FieldInfo[] skillAttributeStructFieldInfos = skillAttributeStructType.GetFields();
foreach (FieldInfo fieldInfo in skillAttributeStructFieldInfos)
{
FieldExplanAttribute fieldExplan = fieldInfo.GetCustomAttributes(typeof(FieldExplanAttribute), false).OfType <FieldExplanAttribute>().FirstOrDefault();
if (fieldExplan == null)
{
continue;
}
object[] skillAttributeStructValue = skillAnalysisData.GetValues(fieldInfo.FieldType, id, fieldExplan.GetExplan(1));//explan的第一个下标表示说明
if (skillAttributeStructValue.Length == skillBaseStruct.maxLevel)
{
skillAttributeStructDic.Add(fieldInfo.Name, skillAttributeStructValue);
}
}
for (int j = 0; j < skillBaseStruct.maxLevel; j++)
{
SkillAttributeStruct skillAttributeStruct = new SkillAttributeStruct();
foreach (FieldInfo fieldInfo in skillAttributeStructFieldInfos)
{
if (skillAttributeStructDic.ContainsKey(fieldInfo.Name))
{
if (skillAttributeStructDic[fieldInfo.Name].GetValue(j) == null)
{
if (j > 0)
{
skillAttributeStructDic[fieldInfo.Name].SetValue(skillAttributeStructDic[fieldInfo.Name].GetValue(j - 1), j);
}
else
{
continue;
}
}
fieldInfo.SetValue(skillAttributeStruct, skillAttributeStructDic[fieldInfo.Name].GetValue(j));
}
}
skillBaseStruct.skillAttributeStructs[j] = skillAttributeStruct;
}
}
}
}
}
/// <summary>
/// 显示集合
/// </summary>
private void ShowUIList()
{
uiKeySettingList.Init();
//注意第一项弄成空的
UIListItem firstItem = uiKeySettingList.NewItem();
firstItem.childText.text = "None";
//firstItem.transform.GetChild(1).GetComponent<Text>().text = "None";
firstItem.value = null;
uiKeySettingList.UpdateUI();
//其他项从技能和道具中检索
List <KeyContactStruct> keyContactStructList = new List <KeyContactStruct>();
//单独的技能
foreach (var item in playerState.SkillPoint)
{
if (item.Value <= 0)
{
continue;
}
SkillBaseStruct skillBaseStruct = skillStructData.SearchSkillDatas(temp => temp.skillType == item.Key).FirstOrDefault();
if (skillBaseStruct != null)
{
KeyContactStruct tempKeyContactStruct = new KeyContactStruct();
tempKeyContactStruct.id = (int)item.Key;
tempKeyContactStruct.key = 0;
tempKeyContactStruct.keyContactType = EnumKeyContactType.Skill;
tempKeyContactStruct.name = skillBaseStruct.skillName;
keyContactStructList.Add(tempKeyContactStruct);
}
}
//组合的技能
foreach (var item in playerState.CombineSkills)
{
if (item != null && item.Count(temp => temp == EnumSkillType.None) < 4)
{
KeyContactStruct tempKeyContactStruct = new KeyContactStruct();
tempKeyContactStruct.id = SkillCombineStaticTools.GetCombineSkillKey(item);
tempKeyContactStruct.key = 0;
tempKeyContactStruct.keyContactType = EnumKeyContactType.Skill;
tempKeyContactStruct.name = SkillCombineStaticTools.GetCombineSkillsName(item);
keyContactStructList.Add(tempKeyContactStruct);
}
}
//可使用的炼金道具
foreach (var item in playerState.PlayerAllGoods.Where(temp =>
((int)temp.GoodsInfo.EnumGoodsType > (int)EnumGoodsType.Item && (int)temp.GoodsInfo.EnumGoodsType < (int)EnumGoodsType.Item + 1000000) ||
((int)temp.GoodsInfo.EnumGoodsType > (int)EnumGoodsType.Elixir && (int)temp.GoodsInfo.EnumGoodsType < (int)EnumGoodsType.Elixir + 1000000)
))
{
KeyContactStruct tempKeyContactStruct = new KeyContactStruct();
tempKeyContactStruct.id = item.ID;
tempKeyContactStruct.key = 0;
tempKeyContactStruct.keyContactType = EnumKeyContactType.Prap;
tempKeyContactStruct.name = item.GoodsInfo.GoodsName;
keyContactStructList.Add(tempKeyContactStruct);
}
//显示在下拉列表中
foreach (var item in keyContactStructList)
{
UIListItem uiListItem = uiKeySettingList.NewItem();
uiListItem.childText.text = item.name;
uiListItem.value = item;
uiListItem.childImage.enabled = false;
}
//最后的设置
uiKeySettingList.UpdateUI();
nowKeySettingListItem = uiKeySettingList.FirstShowItem();
uiKeySettingList.ShowItem(nowKeySettingListItem);
if (nowKeySettingListItem)
{
nowKeySettingListItem.childImage.enabled = true;
}
selectTargetPanel.gameObject.SetActive(true);
//状态改为选择技能
enumKeySettingType = EnumKeySettingType.Select;
}
/// <summary>
/// 根据技能获取粒子的初始化数据
/// </summary>
/// <param name="playerObj">对象</param>
/// <param name="nowIAttributeState">本次计算所使用的状态数据</param>
/// <param name="skills">技能数组</param>
/// <returns></returns>
public ParticalInitParamData[] GetParticalInitParamData(GameObject playerObj, IAttributeState nowIAttributeState, params SkillBaseStruct[] skills)
{
List <ParticalInitParamData> resultList = new List <ParticalInitParamData>();
ParticalInitParamData particalInitParamData = default(ParticalInitParamData);
ISkillState iSkillState = GameState.Instance.GetEntity <ISkillState>();
PlayerState playerState = DataCenter.Instance.GetEntity <PlayerState>();
EnumSkillType[] skillTyps = skills.Where(temp => temp != null).Select(temp => temp.skillType).OrderBy(temp => (int)temp).ToArray();
//耗魔量
float holdingRate = iSkillState.SkillStartHoldingTime / GameState.BaseSkillStartHoldingTime; //计算蓄力程度
float maxUseMana = nowIAttributeState.MaxUseMana; //当前的最大耗魔上限
float baseUseMana = nowIAttributeState.MustUsedBaseMana; //基础耗魔值
float thisUsedMana = baseUseMana + maxUseMana * holdingRate; //该技能的耗魔值
IPlayerState iPlayerState = GameState.Instance.GetEntity <IPlayerState>();
if (iPlayerState.Mana < thisUsedMana)
{
thisUsedMana = iPlayerState.Mana;
}
//技能附加的特效(特殊效果和debuff)
StatusData statusData = DataCenter.Instance.GetMetaData <StatusData>(); //保存特殊状态的数据
Dictionary <StatusDataInfo.StatusLevelDataInfo, int> statusEffects = new Dictionary <StatusDataInfo.StatusLevelDataInfo, int>(); //特殊效果对应该等级数据与对应等级字典
foreach (SkillBaseStruct skillBaseStruct in skills)
{
if (skillBaseStruct == null)
{
continue;
}
//选取debuff和特殊效果
IEnumerable <EnumStatusEffect> enumStatusEffects = skillBaseStruct.skillStatusEffect.Where(temp => (temp > EnumStatusEffect.DebuffStart && temp < EnumStatusEffect.DebuffEnd) || (temp > EnumStatusEffect.SpecialStart && temp < EnumStatusEffect.SpecialEnd));
foreach (EnumStatusEffect enumStatusEffect in enumStatusEffects)
{
StatusDataInfo statusDataInfo = statusData[enumStatusEffect];
if (statusDataInfo == null)
{
continue;
}
int level = 0;
playerState.SkillPoint.TryGetValue(skillBaseStruct.skillType, out level);
StatusDataInfo.StatusLevelDataInfo statusLevelDataInfo = statusDataInfo[level];
if (statusLevelDataInfo != null)
{
if (statusEffects.Count(temp => temp.Key.EffectType == enumStatusEffect) > 0)//如果已经存在相同类型的特效
{
KeyValuePair <StatusDataInfo.StatusLevelDataInfo, int> tempStatusEffect = statusEffects.FirstOrDefault(temp => temp.Key.EffectType == enumStatusEffect);
int nowLevel = tempStatusEffect.Value;
if (nowLevel < level)//计算当前存放的特效等级是否高于新加的等级
{
statusEffects.Remove(tempStatusEffect.Key);
statusEffects.Add(statusLevelDataInfo, level);
}
}
else
{
statusEffects.Add(statusLevelDataInfo, level);
}
}
}
}
StatusDataInfo.StatusLevelDataInfo[] statusLevelDataInfos = statusEffects.Keys.ToArray();
//这几个是基础数据
particalInitParamData.position = playerObj.transform.position + playerObj.transform.forward * 0.3f + playerObj.transform.up * 1.5f;
particalInitParamData.lifeTime = 5;
particalInitParamData.checkCollisionIntervalTime = 1;
particalInitParamData.targetObjs = new GameObject[0];
particalInitParamData.forward = playerObj.transform.forward;
particalInitParamData.color = new Color(0.5f, 0.5f, 0.5f, 0.1f);
particalInitParamData.layerMask = LayerMask.GetMask("Monster", "Default");
//下面的是变化数据
//颜色
SkillBaseStruct combine_secondSkill = skills.Where(temp => temp != null).FirstOrDefault(temp => temp.skillType > EnumSkillType.MagicCombinedLevel2Start && temp.skillType < EnumSkillType.MagicCombinedLevel2End);
if (combine_secondSkill != null)
{
switch (combine_secondSkill.skillType)
{
case EnumSkillType.YSX01: //火元素
particalInitParamData.color = Color.red;
break;
case EnumSkillType.YSX02: //水元素
particalInitParamData.color = Color.blue;
break;
case EnumSkillType.YSX03: //土元素
particalInitParamData.color = Color.yellow;
break;
case EnumSkillType.YSX04: //风元素
particalInitParamData.color = Color.green;
break;
case EnumSkillType.SM06: //冰元素
particalInitParamData.color = Color.cyan;
break;
case EnumSkillType.SM07: //雷元素
particalInitParamData.color = new Color(0.5f, 0, 0.5f, 1);
break;
case EnumSkillType.DSM03: //光明元素
case EnumSkillType.XYX01_Target: //光明信仰基础_对敌军
particalInitParamData.color = Color.white;
break;
case EnumSkillType.DSM04: //黑暗元素
case EnumSkillType.XYX02_Target: //黑暗信仰基础_对敌军
particalInitParamData.color = Color.black;
break;
case EnumSkillType.XYX03_Target: //生物信仰基础_对敌军
particalInitParamData.color = new Color(0, 1, 0.2f, 1);
break;
case EnumSkillType.XYX04_Target: //自然信仰基础_对敌军
//颜色选择为当前环境对应的元素
IEnvironment iEnvironment = GameState.Instance.GetEntity <IEnvironment>();
switch (iEnvironment.TerrainEnvironmentType)
{
case EnumEnvironmentType.Plain:
particalInitParamData.color = new Color(0.5f, 0, 0.5f, 1);
break;
case EnumEnvironmentType.Swamp:
particalInitParamData.color = Color.blue;
break;
case EnumEnvironmentType.Desert:
particalInitParamData.color = Color.yellow;
break;
case EnumEnvironmentType.Forest:
particalInitParamData.color = Color.green;
break;
case EnumEnvironmentType.Volcano:
particalInitParamData.color = Color.red;
break;
}
break;
}
}
//技能最基础表现形式
SkillBaseStruct combine_firstSkill = skills.Where(temp => temp != null).FirstOrDefault(temp => temp.skillType > EnumSkillType.MagicCombinedLevel1Start && temp.skillType < EnumSkillType.MagicCombinedLevel1End);
IMonsterCollection iMonsterCollection = GameState.Instance.GetEntity <IMonsterCollection>();
GameObject selectTargetObj = null;//魔力导向选中的对象
if (combine_firstSkill != null)
{
switch (combine_firstSkill.skillType)
{
case EnumSkillType.FS01: //奥数弹
particalInitParamData.range = 20; //表示距离
particalInitParamData.CollisionCallBack = temp => CalculateCombineMagicHurt(nowIAttributeState, temp, thisUsedMana, statusLevelDataInfos, skillTyps);
break;
case EnumSkillType.FS02: //奥数震荡
particalInitParamData.range = 1; //表示比例
particalInitParamData.CollisionCallBack = temp => CalculateCombineMagicHurt(nowIAttributeState, temp, thisUsedMana, statusLevelDataInfos, skillTyps);
particalInitParamData.position = playerObj.transform.position + playerObj.transform.forward * 2f;
break;
case EnumSkillType.FS03: //魔力屏障
particalInitParamData.range = 1; //表示比例
particalInitParamData.CollisionCallBack = temp => CalculateCombineMagicHurt(nowIAttributeState, temp, thisUsedMana, statusLevelDataInfos, skillTyps);
break;
case EnumSkillType.FS04: //魔力导向
//查找前方45度方位内距离自己最近的怪物
GameObject[] selectObjs = iMonsterCollection.GetMonsters(playerObj, 45, 20);
if (selectObjs != null && selectObjs.Length > 0)
{
selectTargetObj = selectObjs[0];
}
if (selectTargetObj)
{
particalInitParamData.range = Vector3.Distance(selectTargetObj.transform.position, playerObj.transform.position);//表示距离
particalInitParamData.targetObjs = new GameObject[] { selectTargetObj };
particalInitParamData.CollisionCallBack = temp => CalculateCombineMagicHurt(nowIAttributeState, temp, thisUsedMana, statusLevelDataInfos, skillTyps);
}
else
{
particalInitParamData.range = 10;
}
break;
case EnumSkillType.MFS05: //魔力脉冲
particalInitParamData.range = 1; //表示比例
if (combine_secondSkill != null)
{
switch (combine_secondSkill.skillType)
{
case EnumSkillType.YSX03: //土元素 大地咆哮
case EnumSkillType.YSX04: //风元素 风暴突袭
case EnumSkillType.SM06: //冰元素 寒霜吐息
particalInitParamData.position = playerObj.transform.position + playerObj.transform.forward * 1f;
break;
}
}
particalInitParamData.CollisionCallBack = temp => CalculateCombineMagicHurt(nowIAttributeState, temp, thisUsedMana, statusLevelDataInfos, skillTyps);
break;
}
}
resultList.Add(particalInitParamData);
//第三阶段的连续魔力导向有点特殊
SkillBaseStruct combine_thirdSkill = skills.Where(temp => temp != null).FirstOrDefault(temp => temp.skillType > EnumSkillType.MagicCombinedLevel3Start && temp.skillType < EnumSkillType.MagicCombinedLevel3End);
if (combine_thirdSkill != null && combine_thirdSkill.skillType == EnumSkillType.MFS06)
{
//查找周围距离查找到的怪物的最近的怪物
if (selectTargetObj)
{
GameObject[] nextObjs = iMonsterCollection.GetMonsters(selectTargetObj, -1, 100);//测试用100 默认是10
Queue <GameObject> queueNextObj = new Queue <GameObject>();
queueNextObj.Enqueue(selectTargetObj);
foreach (var item in nextObjs)
{
queueNextObj.Enqueue(item);
}
while (queueNextObj.Count > 1)
{
GameObject firstObj = queueNextObj.Dequeue(); //第一个怪物
GameObject secondObj = queueNextObj.Peek(); //第二个怪物
ParticalInitParamData temp_particalInitParamData = particalInitParamData;
temp_particalInitParamData.forward = (secondObj.transform.position - firstObj.transform.position).normalized;
temp_particalInitParamData.position = firstObj.transform.position + temp_particalInitParamData.forward;
temp_particalInitParamData.range = Vector3.Distance(firstObj.transform.position, secondObj.transform.position);
temp_particalInitParamData.targetObjs = new GameObject[] { secondObj };
temp_particalInitParamData.CollisionCallBack = (temp) => CalculateCombineMagicHurt(nowIAttributeState, temp, thisUsedMana, statusLevelDataInfos, skillTyps);
resultList.Add(temp_particalInitParamData);
}
}
}
return(resultList.ToArray());
}
