public IEnumerator ToHurt(RoleTransferAttackInfo attackInfo)
{
if (m_RoleFSMMgr == null)
{
yield break;
}
SkillEntity skillEntity = SkillDBModel.Instance.Get(attackInfo.SkillId);
SkillLevelEntity skillLevelEntity = SkillLevelDBModel.Instance.GetEnityBySkillIdAndSkillLevel(attackInfo.SkillId, attackInfo.SkillLevel);
if (skillEntity == null || skillLevelEntity == null)
{
yield break;
}
yield return(new WaitForSeconds(skillEntity.ShowHurtEffectDelaySecond));
//¼õѪ
m_RoleFSMMgr.CurRoleCtrl.CurRoleInfo.CurrentHP -= attackInfo.HurtValue;
if (OnHurt != null)
{
OnHurt();
}
if (m_RoleFSMMgr.CurRoleCtrl.CurRoleInfo.CurrentHP < 0)
{
m_RoleFSMMgr.CurRoleCtrl.CurRoleInfo.CurrentHP = 0;
m_RoleFSMMgr.CurRoleCtrl.ToDie();
yield break;
}
//²¥·ÅÊÜÉËÌØЧ
int fontSize = 1;
Color color = Color.red;
if (attackInfo.IsCri)
{
fontSize = 2;
color = Color.yellow;
}
UISceneCtrl.Instance.CurrentUIScene.HUD.NewText("- " + attackInfo.HurtValue.ToString(), m_RoleFSMMgr.CurRoleCtrl.transform, color, fontSize, 15f, -1f, 2.2f, UnityEngine.Random.Range(0, 2) == 1 ? bl_Guidance.LeftDown : bl_Guidance.RightDown);
if (!m_RoleFSMMgr.CurRoleCtrl.IsRigibody)
{
m_RoleFSMMgr.ChangeState(RoleState.Hurt);
}
}
/// <summary> 计算攻击信息 </summary>
/// <param name="enemy"></param>
/// <param name="entity"></param>
/// <returns></returns>
private RoleTransferAttackInfo CalculateHurtValue(RoleCtrl enemy, SkillEntity entity)
{
if (enemy == null || entity == null)
{
return(null);
}
int skillLevel = m_CurrRoleCtrl.CurrRoleInfo.GetSkillLevel(entity.Id);
RoleTransferAttackInfo attackInfo = new RoleTransferAttackInfo();
attackInfo.AttackRoleId = m_CurrRoleCtrl.CurrRoleInfo.RoleId;
attackInfo.AttackRolePos = m_CurrRoleCtrl.transform.position;
attackInfo.BeAttackRoleId = enemy.CurrRoleInfo.RoleId;
attackInfo.SkillId = entity.Id;
attackInfo.SkillLevel = skillLevel;
attackInfo.IsAbnormal = entity.AbnormalState == 1;
//1.攻击数值 = 攻击者综合战斗力 * (技能伤害倍率 * 0.001f)
float attackValue = (int)(m_CurrRoleCtrl.CurrRoleInfo.Fighting * (entity.HurtValueRate + entity.HurtValueRateUp * (skillLevel - 1)) * 0.001f);
//2.基础伤害 = 攻击数值 * 攻击数值/(攻击数值+被攻击者的防御)
float baseHurt = attackValue * attackValue / (attackValue + enemy.CurrRoleInfo.Defense);
//3.暴击率 = 攻击方暴击/(被攻击方暴击*5);
float criValue = m_CurrRoleCtrl.CurrRoleInfo.GetFinalCri() / (float)enemy.CurrRoleInfo.GetFinalCri();
//暴击率的最大值为50%
criValue = criValue > 0.5f ? 0.5f : criValue;
//4.是否暴击
bool isCri = UnityEngine.Random.Range(0f, 1f) <= criValue;
//5.暴击伤害倍率 = 暴击？1.5f:1f
float criHurt = isCri ? 1.5f : 1f;
//6.随机数 = 0.9f-1.1f
float random = UnityEngine.Random.Range(0.9f, 1.1f);
//7.最终伤害 = 基础伤害 * 暴击伤害倍率 * 随机数
int finalHurt = Mathf.RoundToInt(baseHurt * criHurt * random);
finalHurt = finalHurt < 1 ? 1 : finalHurt;
attackInfo.HurtValue = finalHurt;
attackInfo.IsCri = isCri;
return(attackInfo);
}
private RoleTransferAttackInfo CalculationHurtValue(RoleCtrl enemy, SkillEntity skillEntity, SkillLevelEntity skillLevelEntity)
{
if (enemy == null || skillEntity == null || skillLevelEntity == null)
{
return(null);
}
RoleTransferAttackInfo t = new RoleTransferAttackInfo();
t.AttackRoleID = m_RoleCtrl.CurRoleInfo.RoleId;
t.AttackRolePos = m_RoleCtrl.transform.position;
t.BeAttaclRoleID = enemy.CurRoleInfo.RoleId;
t.SkillId = skillEntity.Id;
t.SkillLevel = skillLevelEntity.Level;
t.IsAbnormal = skillEntity.AbnormalState == 1;
//计算伤害
//1.攻击数值=攻击方的综合战斗力*（技能的伤害倍率*0.01f）
float attackValue = m_RoleCtrl.CurRoleInfo.Fighting * (skillLevelEntity.HurtValueRate * 0.01f);
//2.基础伤害=g攻击数值*攻击数值/（攻击数值+被攻击方的防御）
float baseHurt = attackValue * attackValue / (attackValue * enemy.CurRoleInfo.Defense);
//3.暴击概率=0.05f+(攻击方的暴击/（攻击方的暴击+防御方的抗性）)*0.1f
float cri = 0.05f + (m_RoleCtrl.CurRoleInfo.Cri / (m_RoleCtrl.CurRoleInfo.Cri / (float)enemy.CurRoleInfo.Res)) * 0.1f;
cri = cri > 0.5f ? 0.5f : cri;
//4.是否暴击=0-1随机数<=随机数
bool isCri = Random.Range(0f, 1f) <= cri;
//5.暴击伤害倍率=有暴击？1.5f:1f
float criHurt = isCri ? 1.5f : 1f;
//6.随机数 0.9f-1.1f
float random = Random.Range(0.9f, 1.1f);
//7.最终伤害 =基础伤害*暴击伤害倍率*随机数
int hurtValue = (int)(baseHurt * criHurt * random);
hurtValue = hurtValue < 1 ? 1 : hurtValue;
t.IsCri = isCri;
t.HurtValue = hurtValue;
return(t);
}
/// <summary>
///
/// </summary>
/// <param name="attackValue">受到的攻击力</param>
/// <param name="delay">延迟时间</param>
public void ToHurt(RoleTransferAttackInfo attackInfo)
{
StartCoroutine(m_Hurt.ToHurt(attackInfo));
}
public bool ToAttackBySkillId(AttackType attackType, int skillId)
{
if (m_RoleFSMMgr == null || m_RoleCtrl.IsRigibody)
{
if (attackType == AttackType.SkillAttack)
{
m_FollowSkillId = skillId;
}
return(false);
}
m_FollowSkillId = -1;
#region
//只有主角和怪参与数值计算
if (m_RoleCtrl.CurRoleType == RoleType.MainPlayer || m_RoleCtrl.CurRoleType == RoleType.Monster)
{
SkillEntity skillEntity = SkillDBModel.Instance.Get(skillId);
if (skillEntity == null)
{
return(false);
}
int skillLevel = 1;
if (m_RoleCtrl.CurRoleType == RoleType.MainPlayer)
{
skillLevel = ((RoleInfoMainPlayer)m_RoleCtrl.CurRoleInfo).GetSkillLevel(skillId);
}
SkillLevelEntity skillLevelEnity = SkillLevelDBModel.Instance.GetEnityBySkillIdAndSkillLevel(skillId, skillLevel);
//主角
if (m_RoleCtrl.CurRoleType == RoleType.MainPlayer)
{
if (skillLevelEnity.SpendMP > m_RoleCtrl.CurRoleInfo.CurrentMP)
{
return(false);
}
m_RoleCtrl.CurRoleInfo.CurrentMP -= skillLevelEnity.SpendMP;
if (m_RoleCtrl.CurRoleInfo.CurrentMP < 0)
{
m_RoleCtrl.CurRoleInfo.CurrentMP = 0;
}
if (m_RoleCtrl.OnMPChange != null)
{
m_RoleCtrl.OnMPChange(ValueChangeType.Reduce);
}
}
//暂时 只有玩家才寻找敌人
m_EnemyList.Clear();
if (m_RoleCtrl.CurRoleType == RoleType.MainPlayer)
{
int attackTargetCount = skillEntity.AttackTargetCount;
if (attackTargetCount == 1)
{
//单体攻击
if (m_RoleCtrl.LockEnemy != null)
{
//有锁定敌人
m_EnemyList.Add(m_RoleCtrl.LockEnemy);
}
else
{
//没有锁定敌人
SearchAndSortEnemys(skillEntity.AreaAttackRadius);
bool isFind = false;
for (int i = 0; i < m_SearchEnemyList.Count; i++)
{
RoleCtrl lockEnemy = m_SearchEnemyList[i].GetComponent <RoleCtrl>();
if (lockEnemy.CurRoleType == RoleType.MainPlayer || lockEnemy.FSM.CurrentRoleStateEnum == RoleState.Die)
{
continue;
}
m_EnemyList.Add(lockEnemy);
m_RoleCtrl.LockEnemy = lockEnemy;
break;
}
if (!isFind)
{
//找不到敌人
return(false);
}
}
}
else
{
//群体攻击
int needCount = attackTargetCount;
if (m_RoleCtrl.LockEnemy != null)
{
//有锁定敌人
m_EnemyList.Add(m_RoleCtrl.LockEnemy);
needCount--;
SearchAndSortEnemys(skillEntity.AreaAttackRadius);
//循环加入搜索到的敌人
for (int i = 0; i < m_SearchEnemyList.Count; i++)
{
RoleCtrl lockEnemy = m_SearchEnemyList[i].GetComponent <RoleCtrl>();
if (lockEnemy.CurRoleInfo.RoleId == m_RoleCtrl.LockEnemy.CurRoleInfo.RoleId || lockEnemy.CurRoleType == RoleType.MainPlayer || lockEnemy.FSM.CurrentRoleStateEnum == RoleState.Die)
{
continue;
}
if (i + 1 > needCount)
{
break;
}
m_EnemyList.Add(lockEnemy);
}
}
else
{
//没有锁定敌人
SearchAndSortEnemys(skillEntity.AreaAttackRadius);
if (m_SearchEnemyList.Count > 0)
{
for (int i = 0; i < m_SearchEnemyList.Count; i++)
{
if (i + 1 > needCount)
{
break;
}
RoleCtrl lockEnemy = m_SearchEnemyList[i].GetComponent <RoleCtrl>();
if (lockEnemy.CurRoleType == RoleType.MainPlayer || lockEnemy.FSM.CurrentRoleStateEnum == RoleState.Die)
{
continue;
}
if (i == 0)
{
m_RoleCtrl.LockEnemy = lockEnemy;
}
m_EnemyList.Add(lockEnemy);
}
}
else
{
return(false);
}
}
}
}
else
{
m_EnemyList.Add(m_RoleCtrl.LockEnemy);
}
for (int i = 0; i < m_EnemyList.Count; i++)
{
RoleTransferAttackInfo t = CalculationHurtValue(m_EnemyList[i], skillEntity, skillLevelEnity);
if (t == null)
{
return(false);
}
m_EnemyList[i].ToHurt(t);
}
}
#endregion
#region 动画相关
if (m_StateAttak == null)
{
m_StateAttak = (RoleStateAttack)m_RoleFSMMgr.GetState(RoleState.Attack);
if (m_StateAttak == null)
{
return(false);
}
}
m_RoleFSMMgr.CurRoleCtrl.CurAttackInfo = GetAttackInfoBySkillId(attackType, skillId);
m_StateAttak.AnimatorCondition = (attackType == AttackType.PhyAttack ? ToAnimatorCondition.ToPhyAttack.ToString() : ToAnimatorCondition.ToSkillAttack.ToString());
m_StateAttak.AnimatorConditionValue = m_RoleFSMMgr.CurRoleCtrl.CurAttackInfo.Index;
KeyValuePair <string, int> stateValue = GetAnimatorName(attackType, m_RoleFSMMgr.CurRoleCtrl.CurAttackInfo.Index);
m_StateAttak.CurAnimatorName = stateValue.Key;
m_StateAttak.CurrentStateValue = stateValue.Value;
m_RoleFSMMgr.ChangeState(RoleState.Attack);
#endregion
return(true);
}
/// <summary> 角色受伤 </summary>
/// <param name="attackInfo"></param>
public IEnumerator ToHurt(RoleTransferAttackInfo attackInfo)
{
if (m_CurrRoleFSMMgr == null)
{
yield break;
}
//如果角色已经死亡了 直接返回
if (m_CurrRoleFSMMgr.CurrRoleStateEnum == RoleState.Die)
{
yield break;
}
SkillEntity skillEntity = SkillDBModel.Instance.Get(attackInfo.SkillId);
if (skillEntity == null)
{
yield break;
}
yield return(new WaitForSeconds(skillEntity.ShowHurtEffectDelaySecond));
//1.减血
m_CurrRoleFSMMgr.CurrRoleCtrl.CurrRoleInfo.CurrHP -= attackInfo.HurtValue;
int fontSize = 15;
Color color = Color.red;
if (attackInfo.IsCri)
{
fontSize = 30;
color = Color.yellow;
}
UISceneCtrl.Instance.CurrentUIScene.HUDText.NewText("- " + attackInfo.HurtValue, m_CurrRoleFSMMgr.CurrRoleCtrl.transform, color, fontSize, 15f, -1f, 2.2f, UnityEngine.Random.Range(0, 2) == 1? bl_Guidance.RightDown:bl_Guidance.LeftDown);
if (OnRoleHurt != null)
{
OnRoleHurt();
}
if (m_CurrRoleFSMMgr.CurrRoleCtrl.CurrRoleInfo.CurrHP <= 0)
{
//角色死亡
m_CurrRoleFSMMgr.CurrRoleCtrl.CurrRoleInfo.CurrHP = 0;
m_CurrRoleFSMMgr.CurrRoleCtrl.ToDie();
yield break;
}
//2.播放受伤特效
Transform hurtTrans = EffectManager.Instance.PlayEffect("Effect_Hurt", "Common");
//TODO 设置特效位置
hurtTrans.position = m_CurrRoleFSMMgr.CurrRoleCtrl.transform.position;
hurtTrans.rotation = m_CurrRoleFSMMgr.CurrRoleCtrl.transform.rotation;
EffectManager.Instance.DestroyEffect(hurtTrans, 2f);
//3.弹出受伤数字 HUDText(包括暴击效果)
//4.屏幕泛红
//不是僵直状态才播放受伤动画
if (!m_CurrRoleFSMMgr.CurrRoleCtrl.IsRigidity)
{
m_CurrRoleFSMMgr.ChangeState(RoleState.Hurt);
}
}
