Unity技能系统（二）
Demo展示：
五.技能管理和释放
1.CharacterSkillSystem
技能系统类，给外部（技能按钮，按键）提供技能释放方法；
技能释放逻辑：
按顺序判定条件，成立怎继续，否则返回；
最终调用CharacterSkillManager中的DeploySkill方法；传递参数为SkillData；
提供了随机技能方法；
/// <summary>
/// 角色系统
/// </summary>
[RequireComponent(typeof(CharacterSkillManager))]
public class CharacterSkillSystem : MonoBehaviour
{
//技能管理
public CharacterSkillManager chSkillMgr;
//角色状态
private CharacterStatus chStatus;
//角色动画
private Animator mAnimator;
//当前使用的技能
private SkillData currentUseSkill;
//当前攻击的目标
private Transform currentSelectedTarget;
//初始化
public void Start()
{
mAnimator = GetComponent<Animator>();
chSkillMgr = GetComponent<CharacterSkillManager>();
chStatus = GetComponent<CharacterStatus>();
}
/// <summary>
/// 使用指定技能
/// </summary>
/// <param name="skillid">技能编号</param>
/// <param name="isBatter">是否连击</param>
public void AttackUseSkill(int skillid, bool isBatter = false)
{
//如果是连击，找当前技能的下一个连击技能
if (currentUseSkill != null && isBatter)
skillid = currentUseSkill.skill.nextBatterId;
//准备技能
currentUseSkill = chSkillMgr.PrepareSkill(skillid);
if (currentUseSkill != null)
{
//选中释放技能调用
if ((currentUseSkill.skill.damageType & DamageType.Select) == DamageType.Select)
{
var selectedTaget = SelectTarget();
if (currentUseSkill.skill.attckTargetTags.Contains("Player"))
selectedTaget = gameObject;
if (selectedTaget != null)
{
CharacterStatus selectStatus = null;
//修改成获取characterStatus中的Selected节点设置隐藏；
if (currentSelectedTarget != null)
{
selectStatus = currentSelectedTarget.GetComponent<CharacterStatus>();
selectStatus.selected.SetActive(false);
}
currentSelectedTarget = selectedTaget.transform;
selectStatus = currentSelectedTarget.GetComponent<CharacterStatus>();
selectStatus.selected.SetActive(true);
//buff技能
if ((currentUseSkill.skill.damageType & DamageType.Buff) == DamageType.Buff)
{
foreach (var buff in currentUseSkill.skill.buffType)
{
//加bufficon
GameObject uiPortrait = selectStatus.uiPortrait.gameObject;
MonsterMgr.I.HideAllEnemyPortraits();
uiPortrait.SetActive(true);
uiPortrait.transform.SetAsLastSibling();
selectStatus.uiPortrait.AddBuffIcon(buff, currentUseSkill.skill.buffDuration);
//已有该buff刷新
bool exist = false;
var buffs = selectedTaget.GetComponents<BuffRun>();
foreach (var it in buffs)
{
if (it.bufftype == buff)
{
it.Reset();
exist = true;
break;
}
}
if (exist)
continue;
//添加新buff
var buffRun = selectedTaget.AddComponent<BuffRun>();
buffRun.InitBuff(buff, currentUseSkill.skill.buffDuration,
currentUseSkill.skill.buffValue, currentUseSkill.skill.buffInterval);
}
return;
}
//转向目标
//transform.LookAt(currentSelectedTarget);
chSkillMgr.DeploySkill(currentUseSkill);
mAnimator.Play(currentUseSkill.skill.animtionName);
}
}
else
{
chSkillMgr.DeploySkill(currentUseSkill);
mAnimator.Play(currentUseSkill.skill.animtionName);
}
}
}
/// <summary>
/// 随机选择技能
/// </summary>
public void RandomSelectSkill()
{
if (chSkillMgr.skills.Count > 0)
{
int index = UnityEngine.Random.Range(0, chSkillMgr.skills.Count);
currentUseSkill = chSkillMgr.PrepareSkill(chSkillMgr.skills[index].skill.skillID);
if (currentUseSkill == null) //随机技能未找到或未冷却结束
currentUseSkill = chSkillMgr.skills[0]; //用技能表中第一个（默认技能）做补充
}
}
//选择目标
private GameObject SelectTarget()
{
//发一个球形射线，找出所有碰撞体
var colliders = Physics.OverlapSphere(transform.position, currentUseSkill.skill.attackDisntance);
if (colliders == null || colliders.Length == 0) return null;
//从碰撞体列表中挑出所有的敌人
String[] attTags = currentUseSkill.skill.attckTargetTags;
var array = CollectionHelper.Select<Collider, GameObject>(colliders, p => p.gameObject);
//正前方，tag正确，血量大于0,处于正前方的敌人
array = CollectionHelper.FindAll<GameObject>(array,
p => Array.IndexOf(attTags, p.tag) >= 0
&& p.GetComponent<CharacterStatus>().HP > 0 &&
Vector3.Angle(transform.forward, p.transform.position - transform.position) <= 90);
if (array == null || array.Length == 0) return null;
//将所有的敌人，按与技能的发出者之间的距离升序排列，
CollectionHelper.OrderBy<GameObject, float>(array,
p => Vector3.Distance(transform.position, p.transform.position));
return array[0];
}
}
2.CharacterSkillManager
技能数据的管理，加载所有技能特效模板进入对象池；
给CharacterSkillSystem提供技能释放接口DeploySkill；
提供技能冷却计算，预留获取cd剩余时间接口给UI，以及获取技能是否在cd中；
[RequireComponent(typeof(CharacterSkillSystem))]
public class CharacterSkillManager : MonoBehaviour
{
/// <summary>管理所有技能的容器</summary>
public List<SkillData> skills = new List<SkillData>();
/// <summary>技能的拥有者</summary>
private CharacterStatus chStatus = null;
private SkillData curSkill;
//添加技能数据
private void AddSkill(string path)
{
SkillTemp skTemp = Instantiate(Resources.Load<SkillTemp>(path));
Skill sk = LoadSkill(skTemp);;
SkillData skd = new SkillData();
skd.skill = sk;
skills.Add(skd);
}
//初始化技能数据(有什么技能)
public void Start()
{
chStatus = GetComponent<CharacterStatus>();
AddSkill("Skill_1");
AddSkill("Skill_2");
AddSkill("Skill_3");
AddSkill("Skill_4");
AddSkill("Skill_5");
foreach (var item in skills)
{
//动态加载技能特效预制体 //Resources/Skill -- 技能特效预制体
if (item.skillPrefab == null && !string.IsNullOrEmpty(item.skill.prefabName))
item.skillPrefab = LoadFxPrefab("Skill/" + item.skill.prefabName);
//Resources/Skill/HitFx 技能伤害特效预制体
if (item.hitFxPrefab == null && !string.IsNullOrEmpty(item.skill.hitFxName))
item.hitFxPrefab = LoadFxPrefab("Skill/" + item.skill.hitFxName);
}
}
//将特效预制件载入到对象池，以备将来使用
private GameObject LoadFxPrefab(string path)
{
var key = path.Substring(path.LastIndexOf("/") + 1);
var go = Resources.Load<GameObject>(path);
GameObjectPool.I.Destory(
GameObjectPool.I.CreateObject(
key, go, transform.position, transform.rotation)
);
return go;
}
//准备技能
public SkillData PrepareSkill(int id)
{
//从技能容器中找出相应ID的技能
var skillData = skills.Find(p => p.skill.skillID == id);
if (skillData != null && //查找到技能
chStatus.SP >= skillData.skill.costSP && //检查角色SP是否够使用该技能
skillData.coolRemain == 0) //且该技能已经冷却结束
{
skillData.Owner = gameObject;
return skillData;
}
return null;
}
//释放技能
public void DeploySkill(SkillData skillData)
{
//开始冷却计时
StartCoroutine(CoolTimeDown(skillData));
//动画某一帧触发技能特效，这里写一个延迟调用的方法，使用动画时间的百分解决特效释放时间问题
if (skillData.skill.delayAnimaTime != 0)
{
curSkill = skillData;
Invoke("DelayDeploySkill", skillData.skill.delayAnimaTime);
return;
}
GameObject tempGo = null;
//创建技能预制体+创建位置的偏移
if ((skillData.skill.damageType & DamageType.FxOffset) == DamageType.FxOffset)
tempGo = GameObjectPool.I.CreateObject(skillData.skill.prefabName, skillData.skillPrefab,
transform.position + transform.forward * skillData.skill.fxOffset, transform.rotation);
//技能有发射点
else if ((skillData.skill.damageType & DamageType.FirePos) == DamageType.FirePos)
tempGo = GameObjectPool.I.CreateObject(skillData.skill.prefabName, skillData.skillPrefab,
chStatus.FirePos.position, chStatus.FirePos.rotation);
if(tempGo == null)
return;
//从预制体对象上找到技能释放对象
var deployer = tempGo.GetComponent<SkillDeployer>();
if (deployer == null)
deployer = tempGo.AddComponent<SkillDeployer>();
//设置要释放的技能————划重点
deployer.skillData = skillData;
//调用释放方法
deployer.DeploySkill();
//技能持续时间过后，技能要销毁
if ((skillData.skill.damageType & DamageType.Bullet) != DamageType.Bullet)
{
if (skillData.skill.durationTime > 0)
GameObjectPool.I.Destory(tempGo, skillData.skill.durationTime);
else
GameObjectPool.I.Destory(tempGo, 0.5f);
}
}
//延迟释放技能
private void DelayDeploySkill()
{
GameObject tempGo = null;
//创建技能预制体+创建位置的偏移
if ((curSkill.skill.damageType & DamageType.FxOffset) == DamageType.FxOffset)
tempGo = GameObjectPool.I.CreateObject(curSkill.skill.prefabName, curSkill.skillPrefab,
transform.position + transform.forward * curSkill.skill.fxOffset, transform.rotation);
else if ((curSkill.skill.damageType & DamageType.FirePos) == DamageType.FirePos)
tempGo = GameObjectPool.I.CreateObject(curSkill.skill.prefabName, curSkill.skillPrefab,
chStatus.FirePos.position, chStatus.FirePos.rotation);
//从预制体对象上找到技能释放对象
var deployer = tempGo.GetComponent<SkillDeployer>();
if (deployer == null)
deployer = tempGo.AddComponent<SkillDeployer>();
//设置要释放的技能
deployer.skillData = curSkill;
//调用释放方法
deployer.DeploySkill();
//技能持续时间过后，技能要销毁
if ((curSkill.skill.damageType & DamageType.Bullet) != DamageType.Bullet)
{
if (curSkill.skill.durationTime > 0)
GameObjectPool.I.Destory(tempGo, curSkill.skill.durationTime);
else
GameObjectPool.I.Destory(tempGo, 0.5f);
}
}
//冷却时间倒计时
public IEnumerator CoolTimeDown(SkillData skillData)
{
skillData.coolRemain = skillData.skill.coolTime;
while (skillData.coolRemain > 0)
{
yield return new WaitForSeconds(0.1f);
skillData.coolRemain -= 0.1f;
}
skillData.coolRemain = 0;
}
//取得冷却倒计时的剩余时间(秒)
public float GetSkillCoolRemain(int id)
{
return skills.Find(p => p.skill.skillID == id).coolRemain;
}
private Skill LoadSkill(SkillTemp skillTemp)
{
Skill sk = skillTemp.skill;
int count = skillTemp.damageType.Length;
for (int i = 0; i < count; ++i)
{
sk.damageType = sk.damageType | skillTemp.damageType[i];
}
return sk;
}
}
3.SkillDeployer
挂载在技能特效上， 执行技能对释放者造成的影响（消耗MP,刷新MPUI）;
对命中目标执行伤害计算，加载受伤特效添加debuff等；
伤害触发分为碰撞触发和目标选择器选中触发；
上面划得重点：
给技能释放器中skillData属性赋值的同时，创建目标选择器，给CharacterStatrus字段赋值;
中间有很多坑点：
1.刷新敌人头像显示，必须要设置显示层级在ui的最下层，同时设置其他UI位置，不能设置Active，禁用buff倒计时计算会失效，也可以将buff倒计时单独管理；
2.检测已有相同buff存在刷新buff时间；
3.多段伤害，每段伤害要重新检测攻击目标，有击退等buff存在；
4.伤害计算单独写方法，方便修改；
5.弹道和碰撞触发伤害的技能，受击特效挂载点不应该是HitFxPos，而是碰撞的接触点，然而使用触发器碰撞没办法返回碰撞点坐标，所以又做了射线检测；但是又会存在新的问题，射线检测只有一条线，没有体积，会造成边缘碰撞时射线未检测到，却已经触发碰撞了；
这里做了处理，射线未检测到却碰撞特效生成在HitFxPos；
可以自行尝试一下在技能特效的前段设置HitFxPos来设置受击特效的位置；
public class SkillDeployer : MonoBehaviour
{
private SkillData m_skillData;
///<summary>敌人选区，选择目标的算法</summary>
public IAttackSelector attackTargetSelector;
private DamageMode damageMode;
//发出者
private CharacterStatus status;
/// <summary> 要释放的技能 </summary>
public SkillData skillData
{
set
{
m_skillData = value;
damageMode = 0;
if ((skillData.skill.damageType & DamageType.Sector) == DamageType.Sector)
damageMode = DamageMode.Sector;
else if ((skillData.skill.damageType & DamageType.Circle) == DamageType.Circle)
damageMode = DamageMode.Circle;
else if ((skillData.skill.damageType & DamageType.Line) == DamageType.Line)
damageMode = DamageMode.Line;
if (damageMode != 0)
attackTargetSelector = SelectorFactory.CreateSelector(damageMode);
status = value.Owner.GetComponent<CharacterStatus>();
}
get { return m_skillData; }
}
/// <summary>技能释放</summary>
public virtual void DeploySkill()
{
if (m_skillData == null) return;
//对自身的影响
SelfImpact(m_skillData.Owner);
//执行伤害的计算
if (damageMode != 0)
StartCoroutine(ExecuteDamage());
}
//执行伤害的计算
protected virtual IEnumerator ExecuteDamage()
{
//按持续时间及，两次伤害间隔，
float attackTimer = 0; //已持续攻击的时间
ResetTargets();
if (skillData.attackTargets != null && skillData.attackTargets.Length > 0)
{
//Debug.Log(skillData.attackTargets[0].name);
foreach (var item in skillData.attackTargets)
{
//刷新敌人头像显示
CharacterStatus targetStatus = item.GetComponent<CharacterStatus>();
GameObject uiPortrait = targetStatus.uiPortrait.gameObject;
MonsterMgr.I.HideAllEnemyPortraits();
uiPortrait.SetActive(true);
uiPortrait.transform.SetAsLastSibling();
//加buff
foreach (var buff in skillData.skill.buffType)
{
//加bufficon
targetStatus.uiPortrait.AddBuffIcon(buff, skillData.skill.buffDuration);
//已有该buff刷新
bool exist = false;
var buffs = item.GetComponents<BuffRun>();
foreach (var it in buffs)
{
if (it.bufftype == buff)
{
it.Reset();
exist = true;
break;
}
}
if (exist)
{
continue;
}
//添加新buff
var buffRun = item.AddComponent<BuffRun>();
buffRun.InitBuff(buff, skillData.skill.buffDuration, skillData.skill.buffValue,
skillData.skill.buffInterval);
}
}
}
do
{
//通过选择器选好攻击目标
ResetTargets();
if (skillData.attackTargets != null && skillData.attackTargets.Length > 0)
{
//Debug.Log(skillData.attackTargets[0].name);
foreach (var item in skillData.attackTargets)
{
//对敌人的影响
TargetImpact(item);
}
}
yield return new WaitForSeconds(skillData.skill.damageInterval);
attackTimer += skillData.skill.damageInterval;
//做伤害数值的计算
} while (skillData.skill.durationTime > attackTimer);
}
private void ResetTargets()
{
if (m_skillData == null)
return;
m_skillData.attackTargets = attackTargetSelector.SelectTarget(m_skillData, transform);
}
private float CirculateDamage(GameObject goTarget)
{
CharacterStatus goStatus = goTarget.GetComponent<CharacterStatus>();
//是否命中计算
float rate = status.hitRate / (float) goStatus.dodgeRate;
if (rate < 1)
{
int max = (int) (rate * 100);
int val = Random.Range(0, 100);
if (val < max)
{
//Debug.Log("Miss");
return 0;
}
}
//普攻的技能伤害为0; 技能有固定伤害*等级加成 + 普攻伤害
var damageVal = status.damage * (1000 / (1000 + goStatus.defence)) +
skillData.skill.damage * (1 + skillData.level * skillData.skill.damageRatio);
return damageVal;
}
///对敌人的影响nag
public virtual void TargetImpact(GameObject goTarget)
{
//出受伤特效
if (skillData.hitFxPrefab != null)
{
//找到受击特效的挂点
Transform hitFxPos = goTarget.GetComponent<CharacterStatus>().HitFxPos;
var go = GameObjectPool.I.CreateObject(
skillData.skill.hitFxName,
skillData.hitFxPrefab,
hitFxPos.position,
hitFxPos.rotation);
go.transform.SetParent(hitFxPos);
GameObjectPool.I.Destory(go, 2f);
}
//受伤
var damageVal = CirculateDamage(goTarget);
var targetStatus = goTarget.GetComponent<CharacterStatus>();
targetStatus.OnDamage((int) damageVal, skillData.Owner);
}
//碰撞触发目标影响
public virtual void TargetImpact(GameObject goTarget, Collider collider)
{
//敌人buff
foreach (var buff in skillData.skill.buffType)
{
//已有该buff刷新
bool exist = false;
var buffs = goTarget.GetComponents<BuffRun>();
foreach (var it in buffs)
{
if (it.bufftype == buff)
{
it.Reset();
exist = true;
break;
}
}
if (exist)
continue;
//添加新buff
var buffRun = goTarget.AddComponent<BuffRun>();
buffRun.InitBuff(buff, skillData.skill.buffDuration,
skillData.skill.buffValue, skillData.skill.buffInterval);
}
//出受伤特效
if (skillData.hitFxPrefab != null)
{
//找到受击特效的挂点，碰撞但未检测到射线点，生成受击特效在hitFxPos处
Ray ray = new Ray(transform.position, transform.forward);
RaycastHit hit;
Physics.Raycast((Ray) ray, out hit, 1000);
if (hit.collider == collider)
{
var go = GameObjectPool.I.CreateObject(
skillData.skill.hitFxName,
skillData.hitFxPrefab,
hit.point,
transform.rotation);
GameObjectPool.I.Destory(go, 2f);
}
else
{
Transform hitFxPos = goTarget.GetComponent<CharacterStatus>().HitFxPos;
var go = GameObjectPool.I.CreateObject(
skillData.skill.hitFxName,
skillData.hitFxPrefab,
hitFxPos.position,
hitFxPos.rotation);
GameObjectPool.I.Destory(go, 2f);
}
}
//受伤
var damageVal = CirculateDamage(goTarget);
var targetStatus = goTarget.GetComponent<CharacterStatus>();
targetStatus.OnDamage((int) damageVal, skillData.Owner);
}
///对自身的影响
public virtual void SelfImpact(GameObject goSelf)
{
//释放者: 消耗SP
var chStaus = goSelf.GetComponent<CharacterStatus>();
if (chStaus.SP != 0)
{
chStaus.SP -= m_skillData.skill.costSP;
chStaus.uiPortrait.RefreshHpMp();
//add+2 魔法条更新
}
}
private void OnTriggerEnter(Collider other)
{
if ((skillData.skill.damageType & DamageType.Bullet) == DamageType.Bullet)
{
if (skillData.skill.attckTargetTags.Contains(other.tag))
{
if (skillData.skill.attackNum == 1)
{
CharacterStatus targetStatus = other.GetComponent<CharacterStatus>();
GameObject uiPortrait = targetStatus.uiPortrait.gameObject;
MonsterMgr.I.HideAllEnemyPortraits();
uiPortrait.SetActive(true);
uiPortrait.transform.SetAsLastSibling();
//加buff
foreach (var buff in skillData.skill.buffType)
{
//加bufficon
targetStatus.uiPortrait.AddBuffIcon(buff, skillData.skill.buffDuration);
}
TargetImpact(other.gameObject, other);
}
else
{
//通过选择器选好攻击目标
IAttackSelector selector = new CircleAttackSelector();
selector.SelectTarget(m_skillData, transform);
if (skillData.attackTargets != null && skillData.attackTargets.Length > 0)
{
foreach (var item in skillData.attackTargets)
{
//刷新敌人头像显示
CharacterStatus targetStatus = item.GetComponent<CharacterStatus>();
GameObject uiPortrait = targetStatus.uiPortrait.gameObject;
MonsterMgr.I.HideAllEnemyPortraits();
uiPortrait.SetActive(true);
uiPortrait.transform.SetAsLastSibling();
//加buff
foreach (var buff in skillData.skill.buffType)
{
//加bufficon
targetStatus.uiPortrait.AddBuffIcon(buff, skillData.skill.buffDuration);
}
//对敌人的影响
TargetImpact(item, other);
}
}
}
GameObjectPool.I.Destory(gameObject);
}
else if (other.CompareTag("Wall"))
{
if (skillData.hitFxPrefab != null)
{
Ray ray = new Ray(transform.position, transform.forward);
RaycastHit hit;
Physics.Raycast((Ray) ray, out hit, 1000);
if (hit.collider != other)
return;
//找到受击特效的挂点
var go = GameObjectPool.I.CreateObject(
skillData.skill.hitFxName,
skillData.hitFxPrefab,
hit.point,
other.transform.rotation);
//go.transform.SetParent(hitFxPos);
GameObjectPool.I.Destory(go, 2f);
}
GameObjectPool.I.Destory(gameObject);
}
}
}
public static Dictionary<BuffType, string> buffIconName = new Dictionary<BuffType, string>();
public static void InitBuffIconName()
{
buffIconName.Add(BuffType.Burn,"Buff_13");
buffIconName.Add(BuffType.Slow,"Buff_15");
buffIconName.Add(BuffType.Stun,"Buff_12");
buffIconName.Add(BuffType.Poison,"Buff_14");
buffIconName.Add(BuffType.BeatBack,"Buff_5");
buffIconName.Add(BuffType.BeatUp,"Buff_4");
buffIconName.Add(BuffType.Pull,"Buff_6");
buffIconName.Add(BuffType.AddDefence,"Buff_3");
buffIconName.Add(BuffType.RecoverHp,"Buff_7");
buffIconName.Add(BuffType.Light,"Buff_8");
}
}
小结
到目前，所有技能逻辑都结束；下一节介绍buff系统和UI显示相关；