/// <summary>
/// 玩家使用技能，根据不同的技能类型用不同的技能管理器
/// </summary>
/// <param name="type"></param>
/// <param name="skillId"></param>
/// <param name="param"></param>
public void OnUseSkill(EnumSkillType type, int skillId, UseSkillParam param)
{
//if (type == EnumSkillType.eSkillType_Skill)
//{
// this.m_skillManager.OnUseSkill(skillId, param);
//}
}
public Skill(string _id)
{
id = _id;
data = new SkillData(id);
type = (EnumSkillType)Enum.Parse(typeof(EnumSkillType), data.type);
}
/// <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);
}
public void LockUseSkill(EnumSkillType type, int skillId, bool bTrue)
{
if (base.Prepared)
{
base.uiBehaviour.m_Button_Attack.SetEnable(bTrue);
}
}
public bool ChangeSkill(EnumSkillType eType, int skillId)
{
//int num = EnumSkillType.eSkillType_Skill == eType
UseSkillBase useSkillBase = null;
bool result = false;
if (this.m_dicSkillState.ContainsKey(eType))
{
this.m_dicSkillState[eType].TryGetValue(skillId, out useSkillBase);
if (useSkillBase != null)
{
if (this.m_curState != null)
{
this.m_curState.OnLeave();
}
this.m_curState = useSkillBase;
// this.m_unCurSkillTypeId =
this.m_eCurSkillType = eType;
this.m_log.Debug(string.Format("ChangeSkill:skillType={0}", this.m_eCurSkillType.ToString()));
this.m_curState.SkillId = skillId;
this.m_curState.OnEnter();
result = true;
return(result);
}
}
ActionState.Singleton.ChangeState(enumSubActionState.eSubActionState_Enable);
return(false);
}
public override bool OnSelectSkill(EnumSkillType eType, int unSkillId)
{
Debug.Log("Use Skill Select Skill");
if (unSkillId == -1)
{
ActionState.Singleton.ChangeState(enumSubActionState.eSubActionState_Enable);
return(true);
}
if (this.m_curState.OnSelectSkill(eType, unSkillId))
{
return(true);
}
if (this.ChangeSkill(eType, unSkillId))
{
SkillBase skill = null;
EnumErrorCodeCheckUse errorCode = skill.CheckUse(Singleton <BeastRole> .singleton.Id);
if (errorCode == EnumErrorCodeCheckUse.eCheckErr_Success)
{
this.m_curState.OnLockOperation();
}
else
{
this.m_curState.ShowErrCheckUse(errorCode);
ActionState.Singleton.ChangeState(enumSubActionState.eSubActionState_Enable);
}
}
return(true);
}
/// <summary>
/// 获取精灵(用于组合)
/// </summary>
/// <param name="enumSkillType"></param>
/// <returns></returns>
public static Sprite GetSpriteCombine(EnumSkillType enumSkillType)
{
if (skillTypeToSpriteCombineDic.ContainsKey(enumSkillType))
{
return(skillTypeToSpriteCombineDic[enumSkillType]);
}
return(null);
}
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="eType"></param>
/// <param name="bVisible"></param>
public void HighlightSkills(EnumSkillType eType, bool bVisible)
{
if (base.Prepared)
{
if (EnumSkillType.eSkillType_Skill == eType)
{
}
}
}
/// <summary>
/// 玩家使用技能
/// </summary>
/// <param name="beastId"></param>
/// <param name="type"></param>
/// <param name="skillId"></param>
/// <param name="param"></param>
public void OnUseSkill(long beastId, EnumSkillType type, int skillId, UseSkillParam param)
{
Beast beast = this.GetBeastById(beastId);
if (beast != null)
{
beast.OnUseSkill(type, skillId, param);
}
}
/// <summary>
/// 高亮显示技能
/// </summary>
/// <param name="eType"></param>
/// <param name="skillIds"></param>
public void HighlightSkills(EnumSkillType eType, List <int> skillIds)
{
if (base.Prepared)
{
if (EnumSkillType.eSkillType_Skill == eType)
{
}
}
}
/// <summary>
/// 高亮显示技能
/// </summary>
/// <param name="eType"></param>
/// <param name="skillIds"></param>
public void HighlightSkills(EnumSkillType eType, List <int> skillIds)
{
if (base.Prepared)
{
if (EnumSkillType.eSkillType_Skill == eType)
{
Debug.Log("高亮显示技能UI");
}
}
}
/// <summary>
/// 点击该技能
/// </summary>
/// <param name="eSkillType"></param>
/// <param name="unSkillId"></param>
/// <returns></returns>
public bool OnClickSkill(EnumSkillType eSkillType, int unSkillId)
{
if (this.m_dicOpState[this.m_eOpStateCurrent].OnClickSkill(eSkillType, unSkillId))
{
this.m_unSkillId = unSkillId;
return(true);
}
else
{
return(false);
}
}
/// <summary>
/// 选择技能
/// </summary>
/// <param name="eSkillType"></param>
/// <param name="unSkillId"></param>
/// <returns></returns>
public bool OnSelectSkill(EnumSkillType eSkillType, int unSkillId)
{
Debug.Log(this.m_eOpStateCurrent.ToString());
if (this.m_dicOpState[this.m_eOpStateCurrent].OnSelectSkill(eSkillType, unSkillId))
{
this.m_unSkillId = unSkillId;
return(true);
}
else
{
return(false);
}
}
public override bool OnSelectSkill(EnumSkillType eType, int unSkillId)
{
if (unSkillId == 0)
{
return(false);
}
else
{
ActionState.Singleton.ChangeState(enumSubActionState.eSubActionState_SkillUse);
ActionState.Singleton.OnSelectSkill(eType, unSkillId);
return(true);
}
}
/// <summary>
/// 设置物理技能攻击
/// </summary>
/// <param name="playerObj">玩家操纵状态对象</param>
/// <param name="physicsSkillStateStruct">本技能释放时的数据状态</param>
/// <param name="skillType">技能类型</param>
/// <param name="weaponTypeByPlayerState">武器类型</param>
public void SetPhysicSkillAttack(IPlayerState iPlayerState, PhysicsSkillStateStruct physicsSkillStateStruct, EnumSkillType skillType, EnumWeaponTypeByPlayerState weaponTypeByPlayerState)
{
if (iPlayerState == null || physicsSkillStateStruct == null)
{
return;
}
IPlayerState _iPlayerState = iPlayerState;
PhysicsSkillStateStruct _physicsSkillStateStruct = physicsSkillStateStruct;
EnumSkillType _SKillType = skillType;
EnumWeaponTypeByPlayerState _WeaponTypeByPlayerState = weaponTypeByPlayerState;
PhysicSkillInjuryDetection physicSkillInjuryDetection = _iPlayerState.PhysicSkillInjuryDetection;
if (physicSkillInjuryDetection != null)
{
physicSkillInjuryDetection.CheckAttack(_SKillType, _WeaponTypeByPlayerState, 1, null, (innerOrder, target) =>
{
return(CalculatePhysicSkillHurt(_SKillType, _WeaponTypeByPlayerState, _physicsSkillStateStruct, innerOrder, target));
});
}
//如果这是冲锋则开启任务(移动对象)
switch (skillType)
{
case EnumSkillType.ZS03:
float zs03Time = 0;
runTaskStruct_Charge.StartTask(0,
() =>
{
zs03Time += Time.deltaTime;
float speedRate = 0;
if (zs03Time < 0.3f)
{
speedRate = 0;
}
else
{
speedRate = 1;
}
_iPlayerState.ForceMoveStruct = new ForceMoveStruct()
{
MoveSpeed = _physicsSkillStateStruct.AttributeState.MoveSpeed * speedRate
};
if (zs03Time > 1f)
{
runTaskStruct_Charge.StopTask();
IAnimatorState iAnimatorState = GameState.Instance.GetEntity <IAnimatorState>();
iAnimatorState.SkillSustainable = false;
}
}, 0, false);
break;
}
}
public List <int> GetCanUseSkillOrEquip(EnumSkillType eType)
{
List <int> result = new List <int>();
if (eType == EnumSkillType.eSkillType_Skill)
{
result = m_skillManager.GetCanUseSkills();
}
else if (eType == EnumSkillType.eSKillType_Equip)
{
}
else if (eType == EnumSkillType.eSkillType_Summelor)
{
}
return(result);
}
/// <summary>
/// 检测攻击
/// </summary>
/// <param name="skillType">技能类型</param>
/// <param name="WeaponType">武器类型</param>
/// <param name="attackSpeed">攻击速度</param>
/// <param name="attackLayerMask">内部设置的检测层</param>
/// <param name="CheckResultAction">检测到碰撞对象后的回调</param>
/// <param name="otherCheck">其他的检测</param>
public void CheckAttack(EnumSkillType skillType, EnumWeaponTypeByPlayerState WeaponType, float attackSpeed, LayerMask?attackLayerMask, Func <int, GameObject, bool> CheckResultAction, int otherCheck = 0)
{
this.CheckResultAction = CheckResultAction;
this.AttackSpeed = attackSpeed;
if (attackLayerMask != null)
{
tempAttackLayerMask = attackLayerMask.Value;
}
else
{
tempAttackLayerMask = null;
}
if (checkStructCollectionArray != null)
{
checkStructCollection = checkStructCollectionArray
.Where(temp => temp.SkillType == skillType) //判断技能类型
.Where(temp => temp.WeaponType == WeaponType || temp.WeaponType == EnumWeaponTypeByPlayerState.None) //判断武器类型(如果设置的是None表示什么武器都可以)
.Where(temp => (temp.OtherCheck == 0 || otherCheck == 0) ? true : temp.OtherCheck == otherCheck) //判断是否存在其他的检测,并判断是否通过检测
.FirstOrDefault();
}
else
{
checkStructCollection = null;
}
if (checkStructCollection != null)
{
//进行设置
checkStructCollection.CheckStructs.ToList().ForEach(temp =>
{
temp.Collider.gameObject.SetActive(true);//打开检测对象
//查找检测脚本
PhysicSkillInjuryDetection_Check physicSkillInjuryDetection_Check = temp.Collider.gameObject.GetComponent <PhysicSkillInjuryDetection_Check>();
//如果为空则添加
if (physicSkillInjuryDetection_Check == null)
{
physicSkillInjuryDetection_Check = temp.Collider.gameObject.AddComponent <PhysicSkillInjuryDetection_Check>();
}
//设置检测层
physicSkillInjuryDetection_Check.checkMask = tempAttackLayerMask != null ? tempAttackLayerMask.Value : this.attackLayerMask;
});
}
nowCheckTime = 0;
skillOrderToObjList = new Dictionary <int, List <GameObject> >();
}
/// <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>
/// <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>
private void UiAddNum_ClickLeftHandle()
{
EnumSkillType enumSkillType = (EnumSkillType)skillID;
//需要通过数据进行验证，然后更改显示
if (CheckSkillPrecondition(enumSkillType))
{
if (CheckMinHandleCanUse(enumSkillType))
{
if (uiAddNum)
{
tempUseSkillPoint--;
uiAddNum.Value--;
}
}
}
if (UpdatePreconditionStateAction != null)
{
UpdatePreconditionStateAction();
}
SkillLittleSettingState = true;
}
/// <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);
}
}
}
public override bool OnClickSkill(EnumSkillType eSkillType, int skillId)
{
return(this.m_curState.OnClickSkill(skillId));
}
private void OnGUI()
{
if (skillTypeToParticalNameDic == null)
{
return;
}
EditorGUILayout.BeginHorizontal();
//左侧的选择配置项按钮面板
EditorGUILayout.BeginVertical(GUILayout.Width(250));
EditorGUILayout.BeginHorizontal();
if (GUILayout.Button("保存", GUILayout.Width(35)))
{
string valueText = SerializeNow(skillTypeToParticalNameDic);
File.WriteAllText(dataDirecotryPath + "/CombinePartical.txt", valueText, Encoding.UTF8);
EditorUtility.DisplayDialog("保存数据", "保存成功!", "确认");
}
GUILayout.Space(100);
if (GUILayout.Button("增量加载资源", GUILayout.Width(100)))
{
ParticalManager.IncrementalLoad();
}
EditorGUILayout.EndHorizontal();
if (GUILayout.Button("添加", GUILayout.Width(35)))
{
if (!skillTypeToParticalNameDic.ContainsKey(-1))
{
skillTypeToParticalNameDic.Add(-1, "None");
}
else
{
EditorUtility.DisplayDialog("提示", "请先编辑之前添加的数据!", "确认");
}
}
leftScroll = EditorGUILayout.BeginScrollView(leftScroll);
KeyValuePair <int, string>[] tempValues = skillTypeToParticalNameDic.ToArray();
Type enumType = typeof(EnumSkillType);
foreach (KeyValuePair <int, string> tempValue in tempValues)
{
EditorGUILayout.BeginHorizontal();
if (GUILayout.Button("×", GUILayout.Width(15)))
{
if (EditorUtility.DisplayDialog("警告!", "将会减去该数据!", "确认", "取消"))
{
skillTypeToParticalNameDic.Remove(tempValue.Key);
}
}
if (object.Equals(tempValue.Key, selectKey))
{
GUILayout.Space(30);
}
string[] showNames = new string[0];
EnumSkillType[] thisSkillTyps = SkillCombineStaticTools.GetCombineSkills(tempValue.Key);
if (thisSkillTyps != null)
{
showNames = thisSkillTyps.Select <EnumSkillType, string>(temp =>
{
FieldInfo fieldInfo = enumType.GetField(temp.ToString());
if (fieldInfo == null)
{
return("");
}
FieldExplanAttribute fieldExplanAttribute = fieldInfo.GetCustomAttributes(typeof(FieldExplanAttribute), false).Select(innerTemp => innerTemp as FieldExplanAttribute).Where(innerTemp => innerTemp != null).FirstOrDefault();
if (fieldExplanAttribute == null)
{
return("");
}
return(fieldExplanAttribute.GetExplan());
}).Where(temp => !string.IsNullOrEmpty(temp)).ToArray();
}
string showName = showNames.Length > 0 ? string.Join("+", showNames) : "None";
if (GUILayout.Button(showName))
{
if (object.Equals(tempValue.Key, selectKey))
{
selectKey = 0;
}
else
{
selectKey = tempValue.Key;
nowSelectSkillTyps = thisSkillTyps;
}
}
EditorGUILayout.EndHorizontal();
}
EditorGUILayout.EndScrollView();
EditorGUILayout.EndVertical();
//第一个技能
EditorGUILayout.BeginVertical();
if (nowSelectSkillTyps == null || nowSelectSkillTyps.Length < 1)
{
nowSelectSkillTyps = new EnumSkillType[] { EnumSkillType.None }
}
;
var enumSkillTypes_First = allSkillTypes.Select(temp =>
{
FieldInfo fieldInfo = enumType.GetField(temp.ToString());
if (fieldInfo == null)
{
return new { type = temp, str = "" }
}
;
FieldExplanAttribute fieldExplanAttriubte = fieldInfo.GetCustomAttributes(typeof(FieldExplanAttribute), false).OfType <FieldExplanAttribute>().Where(innerTemp => innerTemp != null).FirstOrDefault();
if (fieldExplanAttriubte == null)
{
return new { type = temp, str = "" }
}
;
return(new { type = temp, str = fieldExplanAttriubte.GetExplan() });
}).Where(temp => !string.IsNullOrEmpty(temp.str)).Where(temp => temp.type < EnumSkillType.MagicCombinedLevel1End).Reverse();
int index_First = enumSkillTypes_First.Select(temp => temp.type).ToList().IndexOf(nowSelectSkillTyps[0]);
int nowIndex_First = EditorGUILayout.Popup(index_First, enumSkillTypes_First.Select(temp => temp.str).ToArray());
if (nowIndex_First > -1 && nowIndex_First < enumSkillTypes_First.Count())
{
EnumSkillType selectEnumSkillType = enumSkillTypes_First.ToArray()[nowIndex_First].type;
nowSelectSkillTyps[0] = selectEnumSkillType;
}
if (nowSelectSkillTyps[0] < EnumSkillType.MagicCombinedLevel1Start)
{
EnumSkillType[] tempArray = nowSelectSkillTyps;
nowSelectSkillTyps = new EnumSkillType[1];
Array.Copy(tempArray, nowSelectSkillTyps, 1);
}
//第二个技能
if (nowSelectSkillTyps.Length > 0 && nowSelectSkillTyps[0] > EnumSkillType.MagicCombinedLevel1Start)
{
if (nowSelectSkillTyps.Length < 2)
{
EnumSkillType[] tempArray = nowSelectSkillTyps;
nowSelectSkillTyps = new EnumSkillType[2];
Array.Copy(tempArray, nowSelectSkillTyps, 1);
}
var enumSkillTypes_Second = allSkillTypes.Select(temp =>
{
FieldInfo fieldInfo = enumType.GetField(temp.ToString());
if (fieldInfo == null)
{
return new { type = temp, str = "" }
}
;
FieldExplanAttribute fieldExplanAttriubte = fieldInfo.GetCustomAttributes(typeof(FieldExplanAttribute), false).OfType <FieldExplanAttribute>().Where(innerTemp => innerTemp != null).FirstOrDefault();
if (fieldExplanAttriubte == null)
{
return new { type = temp, str = "" }
}
;
return(new { type = temp, str = fieldExplanAttriubte.GetExplan() });
}).Where(temp => !string.IsNullOrEmpty(temp.str)).Where(temp => temp.type <EnumSkillType.MagicCombinedLevel2End && temp.type> EnumSkillType.MagicCombinedLevel2Start);
int index_Second = enumSkillTypes_Second.Select(temp => temp.type).ToList().IndexOf(nowSelectSkillTyps[1]);
int nowIndex_Second = EditorGUILayout.Popup(index_Second, enumSkillTypes_Second.Select(temp => temp.str).ToArray());
if (nowIndex_Second > -1 && nowIndex_Second < enumSkillTypes_Second.Count())
{
EnumSkillType selectEnumSkillType = enumSkillTypes_Second.ToArray()[nowIndex_Second].type;
nowSelectSkillTyps[1] = selectEnumSkillType;
}
}
//第三个技能
if (nowSelectSkillTyps.Length > 1 && nowSelectSkillTyps[1] > EnumSkillType.MagicCombinedLevel2Start)
{
if (nowSelectSkillTyps.Length < 3)
{
EnumSkillType[] tempArray = nowSelectSkillTyps;
nowSelectSkillTyps = new EnumSkillType[3];
Array.Copy(tempArray, nowSelectSkillTyps, 2);
}
var enumSkillTypes_Third = allSkillTypes.Select(temp =>
{
FieldInfo fieldInfo = enumType.GetField(temp.ToString());
if (fieldInfo == null)
{
return new { type = temp, str = "" }
}
;
FieldExplanAttribute fieldExplanAttriubte = fieldInfo.GetCustomAttributes(typeof(FieldExplanAttribute), false).OfType <FieldExplanAttribute>().Where(innerTemp => innerTemp != null).FirstOrDefault();
if (fieldExplanAttriubte == null)
{
return new { type = temp, str = "" }
}
;
return(new { type = temp, str = fieldExplanAttriubte.GetExplan() });
}).Where(temp => !string.IsNullOrEmpty(temp.str)).Where(temp => temp.type <EnumSkillType.MagicCombinedLevel3End && temp.type> EnumSkillType.MagicCombinedLevel3Start);
int index_Third = enumSkillTypes_Third.Select(temp => temp.type).ToList().IndexOf(nowSelectSkillTyps[2]);
int nowIndex_Third = EditorGUILayout.Popup(index_Third, enumSkillTypes_Third.Select(temp => temp.str).ToArray());
if (nowIndex_Third > -1 && nowIndex_Third < enumSkillTypes_Third.Count())
{
EnumSkillType selectEnumSkillType = enumSkillTypes_Third.ToArray()[nowIndex_Third].type;
nowSelectSkillTyps[2] = selectEnumSkillType;
}
}
//第四个技能
if (nowSelectSkillTyps.Length > 2 && nowSelectSkillTyps[2] > EnumSkillType.MagicCombinedLevel3Start)
{
if (nowSelectSkillTyps.Length < 4)
{
EnumSkillType[] tempArray = nowSelectSkillTyps;
nowSelectSkillTyps = new EnumSkillType[4];
Array.Copy(tempArray, nowSelectSkillTyps, 3);
}
var enumSkillTypes_Fourth = allSkillTypes.Select(temp =>
{
FieldInfo fieldInfo = enumType.GetField(temp.ToString());
if (fieldInfo == null)
{
return new { type = temp, str = "" }
}
;
FieldExplanAttribute fieldExplanAttriubte = fieldInfo.GetCustomAttributes(typeof(FieldExplanAttribute), false).OfType <FieldExplanAttribute>().Where(innerTemp => innerTemp != null).FirstOrDefault();
if (fieldExplanAttriubte == null)
{
return new { type = temp, str = "" }
}
;
return(new { type = temp, str = fieldExplanAttriubte.GetExplan() });
}).Where(temp => !string.IsNullOrEmpty(temp.str)).Where(temp => temp.type <EnumSkillType.MagicCombinedLevel4End && temp.type> EnumSkillType.MagicCombinedLevel4Start);
int index_Fourth = enumSkillTypes_Fourth.Select(temp => temp.type).ToList().IndexOf(nowSelectSkillTyps[3]);
int nowIndex_Fourth = EditorGUILayout.Popup(index_Fourth, enumSkillTypes_Fourth.Select(temp => temp.str).ToArray());
if (nowIndex_Fourth > -1 && nowIndex_Fourth < enumSkillTypes_Fourth.Count())
{
EnumSkillType selectEnumSkillType = enumSkillTypes_Fourth.ToArray()[nowIndex_Fourth].type;
nowSelectSkillTyps[3] = selectEnumSkillType;
}
}
//技能粒子对象
if (skillTypeToParticalNameDic.ContainsKey(selectKey))
{
GameObject particalObj = (GameObject)EditorGUILayout.ObjectField(ParticalManager.GetPartical(skillTypeToParticalNameDic[selectKey]), typeof(GameObject), true);
skillTypeToParticalNameDic[selectKey] = ParticalManager.GetName(particalObj);
}
if (GUILayout.Button("保存", GUILayout.Width(35)))
{
int key = SkillCombineStaticTools.GetCombineSkillKey(nowSelectSkillTyps);
if (key == 0 || (key != selectKey && skillTypeToParticalNameDic.ContainsKey(key)))
{
EditorUtility.DisplayDialog("提示", "无法保存该数据!", "确认");
}
else
{
string particalName = "";
if (skillTypeToParticalNameDic.ContainsKey(selectKey))
{
particalName = skillTypeToParticalNameDic[selectKey];
skillTypeToParticalNameDic.Remove(selectKey);
}
skillTypeToParticalNameDic.Add(key, particalName);
selectKey = key;
}
}
EditorGUILayout.EndVertical();
EditorGUILayout.EndHorizontal();
}
}
/// <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>
/// <param name="type"></param>
/// <returns></returns>
public List <int> GetCanUseSkillOrEquip(EnumSkillType type)
{
return(this.Beast.GetCanUseSkillOrEquip(type));
}
/// <summary>
/// 技能锁定不能使用
/// </summary>
public void LockUseSkill(EnumSkillType type, int skillId, bool bTure)
{
DlgBase <DlgMain, DlgMainBehaviour> .singleton.LockUseSkill(type, skillId, bTure);
}
public virtual bool OnSelectSkill(EnumSkillType eSkillType, int skillId)
{
return(false);
}
void OnGUI()
{
if (skillTypeToExplanDic == null)
{
return;
}
EditorGUILayout.BeginHorizontal();
//左侧选择技能
EditorGUILayout.BeginVertical(GUILayout.Width(250));
if (GUILayout.Button("保存"))
{
string valueText_Show = SerializeNow(skillTypeToSpriteIDShowDic);
File.WriteAllText(dataDirectoryPath + "/SkillSprite.txt", valueText_Show, Encoding.UTF8);
string valueText_Combine = SerializeNow(skillTypeToSpriteIDCombineDic);
File.WriteAllText(dataDirectoryPath + "/SkillSprite_Combine.txt", valueText_Combine, Encoding.UTF8);
EditorUtility.DisplayDialog("保存数据", "保存成功!", "确认");
}
EditorGUILayout.LabelField("技能:");
scrollLeft = EditorGUILayout.BeginScrollView(scrollLeft);
foreach (KeyValuePair <EnumSkillType, string> item in skillTypeToExplanDic)
{
int offsetX = 0;
if (item.Key == selectEnumSkillType)
{
offsetX = 20;
}
EditorGUILayout.BeginHorizontal();
GUILayout.Space(offsetX);
if (GUILayout.Button(item.Value))
{
selectEnumSkillType = item.Key;
}
EditorGUILayout.EndHorizontal();
}
EditorGUILayout.EndScrollView();
EditorGUILayout.EndVertical();
EditorGUILayout.BeginVertical();
//右侧显示图片(或粒子?)
//图片
if (skillTypeToExplanDic.ContainsKey(selectEnumSkillType))
{
EditorGUILayout.LabelField("显示图标:");
{
Sprite oldSprite = skillTypeToSpriteShowDic[selectEnumSkillType];
Sprite sprite = (Sprite)EditorGUILayout.ObjectField(oldSprite, typeof(Sprite), true, GUILayout.Width(100), GUILayout.Height(100));
if (!Sprite.Equals(oldSprite, sprite))
{
string spriteID = SpriteManager.GetName(sprite);
skillTypeToSpriteShowDic[selectEnumSkillType] = sprite;
skillTypeToSpriteIDShowDic[selectEnumSkillType] = spriteID;
}
}
EditorGUILayout.LabelField("组合图标:");
{
Sprite oldSprite = skillTypeToSpriteCombineDic[selectEnumSkillType];
Sprite sprite = (Sprite)EditorGUILayout.ObjectField(oldSprite, typeof(Sprite), true, GUILayout.Width(100), GUILayout.Height(100));
if (!Sprite.Equals(oldSprite, sprite))
{
string spriteID = SpriteManager.GetName(sprite);
skillTypeToSpriteCombineDic[selectEnumSkillType] = sprite;
skillTypeToSpriteIDCombineDic[selectEnumSkillType] = spriteID;
}
}
}
EditorGUILayout.EndVertical();
EditorGUILayout.EndHorizontal();
}
public override bool OnSelectSkill(EnumSkillType eType, int skillId)
{
return(false);
}
