using Adon.Game.Data;
using Adon.Game.Data.StructData;
using Adon.Game.BO;
using Adon.Game.Helper;
using Chronos;
using Cinemachine;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Playables;
using WarReport;
using BehaviorDesigner.Runtime;
using X2Battle;
namespace AdonGameKit
{
///
/// 英雄基础类
///
public class BaseHero : BaseCharacterAdon
{
#region readonly
///
/// 前速度字符
///
readonly int m_HashForwardSpeed = Animator.StringToHash("ForwardSpeed");
///
/// 近战攻击字符
///
readonly int m_HashMeleeAttack = Animator.StringToHash("MeleeAttack");
///
/// 冲刺攻击字符
///
readonly int m_HashDashAttack = Animator.StringToHash("DashAttack");
///
/// 后退闪避字符
///
readonly int m_HashDodge = Animator.StringToHash("Dodge");
///
/// 前冲闪避字符
///
readonly int m_HashRush = Animator.StringToHash("Rush");
///
/// 技能字符
///
readonly int m_HashSkill = Animator.StringToHash("Skill");
readonly int m_HashIdle = Animator.StringToHash("Idle");
#endregion
GameObject _targetMonster;
///
/// 目标怪
///
public GameObject m_targetMonster;
///
/// 技能碰撞器
///
public Collider m_SkillCol;
///
/// 是否僵直中
///
private bool isStiff;
///
/// 根时钟
///
private Clock m_clockRoot;
///
/// 玩家时钟
///
public Clock m_clockPlayer;
///
/// 敌人时钟
///
private Clock m_clockEnemy;
///
/// 僵直时间
///
private float stiffTime;
///
/// 是否被击
///
private bool isAttacked;
///
/// 是否治疗
///
private bool isCuring;
///
/// 损伤材质闪光强度
///
private float m_damageFlashScale;
///
/// 损伤材质闪光强度
///
private float m_CuringFlashScale;
///
/// 是否看向目标
///
private bool isHeadlook;
private bool isExtermeTimeZone;//是否进入极限闪避时区
private float m_ExtermeZoneTimer;//极限闪避时区计时
private bool isExtermeDodge;//是否进入极限闪避
private float m_ExtermeDodgeTimer;//极限闪避计时
///
/// 镜头效果组件
///
public PlayableDirector m_PlayableDirector;
public HeroBlur m_HeroBlur;//残影组件
///
/// 检测的攻击范围
///
public float m_AutoAttackRange = 18;
///
/// 近战攻击视野
///
public float m_AttackSight = 3;
///
/// 攻击角度
///
public float m_AttackAngle = 160;
//private GameObject m_targetMonster;
///
/// 推力方向
///
public Vector3 m_ForceDirection;
///
/// 是否切换角色
///
private bool IsSwitchRoles;
///
/// 无敌
///
private bool isGod;
///
/// 无敌时间
///
private float m_GodTime;
private float detectTime;
private bool isStun;
///
/// 网络同步间隔
///
public float netUpdateTime = 0.1f;
public float curUpdateTime = 0;
///
/// 言灵挂件
///
public Dictionary m_YLParts = new Dictionary();
Dictionary buffnum = new Dictionary();//buff计数
protected static readonly int hashHit = Animator.StringToHash("Hit");//打击
protected static readonly int hashHitAngle = Animator.StringToHash("HitAngle");//受击方向
protected static readonly int hashHitDown = Animator.StringToHash("HitDown");//击倒
protected static readonly int hashDie = Animator.StringToHash("Die");//死亡
protected static readonly int hashDieDown = Animator.StringToHash("DieDown");//击飞死亡
protected static readonly int hashStun = Animator.StringToHash("Stun");//眩晕
protected static readonly int hashWin = Animator.StringToHash("Win");//胜利
private Transform attackRangeTran = null;
///
/// 时间器刚体
///
private RigidbodyTimeline3D m_Rigidbody
{
get { return time.rigidbody; }
}
///
/// 时间寻路组件
///
public NavMeshAgentTimeline m_navMeshAgent
{
get { return time.navMeshAgent; }
}
///
/// 头部言灵
///
BaseYLPartAdon _Head_YL;
BaseYLPartAdon _Shoulder_YL;
BaseYLPartAdon _Foot_YL;
///
/// 头部言灵
///
public BaseYLPartAdon m_Head_YL
{
get
{
if (_Head_YL == null)
{
Transform head_YL = X2BattleManager.Instance.mBulletModel.GetCmptRootByType(this, YanLingBonePoint.BonePoint.head);
///获取言灵脚本
_Head_YL = head_YL.GetComponent();
_Head_YL.m_Hero = this;
}
return _Head_YL;
}
}
///
/// 肩部言灵
///
public BaseYLPartAdon m_Shoulder_YL
{
get
{
if (_Shoulder_YL == null)
{
Transform Shoulder_YL = X2BattleManager.Instance.mBulletModel.GetCmptRootByType(this, YanLingBonePoint.BonePoint.shoulder);
///获取言灵脚本
_Shoulder_YL = Shoulder_YL.GetComponent();
_Shoulder_YL.m_Hero = this;
}
return _Shoulder_YL;
}
}
///
/// 脚部言灵
///
public BaseYLPartAdon m_Foot_YL
{
get
{
if (_Foot_YL == null)
{
Transform foot_YL = X2BattleManager.Instance.mBulletModel.GetCmptRootByType(this, YanLingBonePoint.BonePoint.foot);
///获取言灵脚本
_Foot_YL = foot_YL.GetComponent();
_Foot_YL.m_Hero = this;
}
return _Foot_YL;
}
}
protected override void Awake()
{
base.Awake();
m_CameraManagerAdon = gameObject.AddComponent();//添加相机管理
m_CameraManagerAdon.m_Hero = this.transform;
m_HeroBlur = gameObject.AddComponent();//添加残影脚本
m_HeroBlur.enabled = false;
m_fbx.gameObject.GetComponent().SetOwner(this.gameObject);
mCM_ThirdPerson = transform.Find("CMStateDrivenCamera/CM_ThirdPerson").GetComponent();
attackRangeTran = transform.Find("AttackRange");
m_CameraManagerAdon.m_Timeline_CM_Respawn.gameObject.SetActive(false);
}
void Start()
{
m_clockRoot = Timekeeper.instance.Clock("Root");
m_clockPlayer = Timekeeper.instance.Clock("Player");
m_clockEnemy = Timekeeper.instance.Clock("Enemy");
//m_fbx.gameObject.SetActive(true);
////开始场景漫游相机
//CameraManager.Instance.PlaySceneTour();
}
private void OnEnable()
{
if (IsSwitchRoles)
{
BattleCanvas.Instance.userYanlingSkill = BattleUseYanlingSkill;//注册言灵技委托。
BattleCanvas.Instance.cancelyanlingSkill = BattleCancelyanlingSkill;//注册言灵技委托。
m_fbx.gameObject.SetActive(true);
m_CameraManagerAdon.SwitchToCM_TopDown();
SetAnimatorStatusIdle();
}
else
{
//m_fbx.gameObject.SetActive(false);
Invoke("showFBX", 0.5f);//延迟显示角色
}
}
void Update()
{
if (m_bStopTime)//时间暂停
{
if (m_stopTime <= Time.realtimeSinceStartup - lastUpdateTime)
{
Time.timeScale = 1;
m_bStopTime = false;
}
}
if (isGod)
{
//m_CapsuleCollider.enabled = false;
if (m_GodTime <= 0)
{
m_GodTime = 0;
isGod = false;
//m_CapsuleCollider.enabled = true; ;
}
m_GodTime -= time.deltaTime;
}
///检测可锁定的攻击目标
detectTime += time.deltaTime;
if (detectTime >= 0.1f)
{
detectTime = 0;
PlayerHelperAdon.GetNearEnemyDistance(this, m_AutoAttackRange, out _targetMonster);
if (_targetMonster == null)
{
if (m_targetMonster != null)
{
m_targetMonster.GetComponent().ReleaseLock();
m_targetMonster = null;
}
return;
}
if (m_targetMonster != _targetMonster)
{
if (m_targetMonster != null)
{
m_targetMonster.GetComponent().ReleaseLock();
ReleaseTarget();
}
if (_targetMonster != null)
{
_targetMonster.GetComponent().Lock();
}
m_targetMonster = _targetMonster;
TargetRole = _targetMonster.GetComponent();
}
// BOSS 通过服务器刷新血量
if (GameDateManager.Instance.GateVO != null && int.Parse(GameDateManager.Instance.GateVO.Mo.battleType) != (int)BattleDefine.EBattleSceneType.EBattleType_WorldBoss)
{
BattleCanvas.Instance.ShowLockMonsterHP(TargetRole);
}
}
//残影测试
if (Input.GetKeyDown(KeyCode.Q))
{
m_HeroBlur.enabled = false;
m_HeroBlur.enabled = true;
}
// 网络同步
curUpdateTime += Time.deltaTime;
if (curUpdateTime > netUpdateTime)
{
curUpdateTime = curUpdateTime - netUpdateTime;
}
else
{
return;
}
//if (this.mData.UID == HeroPlayerController.Instance.m_Hero.mData.UID)
if (GameDateManager.Instance.isMultiRoom && playerUID == UserProxy.Instance.player.uid)
{
float x = this.transform.position.x;
float y = this.transform.position.y;
float z = this.transform.position.z;
MultiBattleProxy.Instance.SendPostion(x, y, z);
}
}
void showFBX()
{
m_fbx.gameObject.SetActive(true);
m_CameraManagerAdon.m_Timeline_CM_Respawn.gameObject.SetActive(true);
//CameraManager.Instance.StopSceneTour();//停止场景漫游
//判断是否为角色切换,如果是角色切换则不播放出生动作和出生特写镜头
if (IsSwitchRoles)
{
m_CameraManagerAdon.SwitchToCM_TopDown();
SetAnimatorStatusIdle();
}
else
{
m_CameraManagerAdon.m_Timeline_CM_Respawn.gameObject.SetActive(true);
}
}
///
/// 设置是否切换角色
///
///
public void SetIsSwitchRoles(bool isSwitchRoles)
{
IsSwitchRoles = isSwitchRoles;
m_fbx.gameObject.SetActive(true);
if (IsSwitchRoles)
{
BattleCanvas.Instance.userYanlingSkill = BattleUseYanlingSkill;//注册言灵技委托。
BattleCanvas.Instance.cancelyanlingSkill = BattleCancelyanlingSkill;//注册言灵技委托。
}
}
void FixedUpdate()
{
if (isStiff)//僵直
{
if (stiffTime > 0)
{
stiffTime -= Time.deltaTime;
}
else
{
stiffTime = 0;
m_clockRoot.localTimeScale = 1;
//m_clockPlayer.localTimeScale = 1;
//m_clockEnemy.localTimeScale = 1;
//m_Hero.m_Animator.speed = 1;
isStiff = false;
}
}
//受击闪光效果
if (isAttacked)
{
m_damageFlashScale -= time.deltaTime * 10;
if (m_damageFlashScale <= 0)
{
m_damageFlash.gameObject.SetActive(false);
m_damageFlashScale = 0;
isAttacked = false;
}
for (int l = 0; l < m_damageFlashMaterial.Length; l++)
{
m_damageFlashMaterial[l].SetFloat("_Scale", m_damageFlashScale);
}
}
//治愈闪光效果
if (isCuring)
{
m_CuringFlashScale -= time.deltaTime * 2;
if (m_CuringFlashScale <= 0)
{
m_CuringFlashs.gameObject.SetActive(false);
m_CuringFlashScale = 0;
isCuring = false;
}
for (int l = 0; l < m_CuringFlashMaterial.Length; l++)
{
m_CuringFlashMaterial[l].SetFloat("_Scale", m_CuringFlashScale);
}
}
//看向目标
if (m_PerfectLookAtAdon != null)
{
if (isHeadlook == true)//如果看向目标
{
m_PerfectLookAtAdon.m_Weight += 0.03f;//权重增加
}
else
{
m_PerfectLookAtAdon.m_Weight -= 0.03f;//权重递减
}
if (m_PerfectLookAtAdon.m_Weight > 1)
{
m_PerfectLookAtAdon.m_Weight = 1;//限制权重不能大于1
}
else if (m_PerfectLookAtAdon.m_Weight < 0)
{
m_PerfectLookAtAdon.m_Weight = 0;//限制权重不能小于0
}
}
if (isExtermeTimeZone)//进入极限闪避时区
{
m_ExtermeZoneTimer -= Time.deltaTime;//递减极限闪避时区
if (m_ExtermeZoneTimer <= 0)
{
m_ExtermeZoneTimer = 0;
isExtermeTimeZone = false;
}
}
if (isExtermeDodge)//成功极限闪避
{
m_ExtermeDodgeTimer -= Time.deltaTime;//递减极限闪避时区
if (m_ExtermeDodgeTimer <= 0)
{
m_ExtermeDodgeTimer = 0;
isExtermeDodge = false;
FreedExterme();
}
}
}
#region ============================================ MSG ======================================================
///
/// 攻击消息
///
///
public void OnMsg_Attack(Attack_MsgData data)
{
SetAnimatorStatusAttack(data);
}
public void SetAnimatorStatusAttack(Attack_MsgData data)
{
m_Rigidbody.velocity = Vector3.zero;//刚体推力设置为0
m_Animator.SetBool(m_HashMeleeAttack, true);//触发近战攻击动作
data.dir.Normalize();
transform.rotation = Quaternion.LookRotation(data.dir);//看向方向
if (m_targetMonster)
{
LockingTarget();//锁定目标
}
// 网络同步
if (GameDateManager.Instance.isMultiRoom && playerUID == UserProxy.Instance.player.uid)
{
string msgData = CommonManager.Serialize(data);
MultiBattleProxy.Instance.SendStatus("SetBool", msgData);
}
}
///
/// 冲刺攻击
///
///
public void SetAnimatorStatusDash(Rush_MsgData data)
{
m_Rigidbody.velocity = Vector3.zero;//刚体推力设置为0
data.dir.Normalize();
transform.localRotation = Quaternion.LookRotation(data.dir);//看向方向
if (m_targetMonster)
{
LockingTarget();//锁定目标
}
m_Animator.SetTrigger(m_HashDashAttack);//触发冲刺攻击动作
}
///
/// 闪避后退
///
///
public void SetAnimatorStatusDodge()
{
bDodge = true;
m_Animator.SetTrigger(m_HashDodge);
// 网络同步
if (GameDateManager.Instance.isMultiRoom && playerUID == UserProxy.Instance.player.uid)
{
MultiBattleProxy.Instance.SendStatus("Dodge", m_HashDodge.ToString());
}
}
///
/// 闪避前进
///
///
public void SetAnimatorStatusRush()
{
bDodge = true;
m_Animator.SetTrigger(m_HashRush);
// 网络同步
if (GameDateManager.Instance.isMultiRoom && playerUID == UserProxy.Instance.player.uid)
{
MultiBattleProxy.Instance.SendStatus("Rush", m_HashDodge.ToString());
}
}
///
/// 施放必杀
///
public void SetAnimatorStatusSkill()
{
// m_Animator.SetTrigger(m_HashSkill);
// 释放必杀 放入场景
GameObject bishaEffObj = m_Animator.transform.Find("Effect_000/Attacks/skill/skill_101005").gameObject;
GameObject newEffObj = (GameObject)Instantiate(bishaEffObj, bishaEffObj.transform.parent);
newEffObj.SetActive(true);
newEffObj.transform.parent = null;
FBXEvent fe = newEffObj.GetComponent();
fe.SetOwner(this.gameObject);
// 网络同步
if (GameDateManager.Instance.isMultiRoom && playerUID == UserProxy.Instance.player.uid)
{
MultiBattleProxy.Instance.SendStatus("Skill", m_HashSkill.ToString());
}
}
///
/// 等待
///
public void SetAnimatorStatusIdle()
{
m_Animator.SetTrigger(m_HashIdle);
// 网络同步
if (GameDateManager.Instance.isMultiRoom && playerUID == UserProxy.Instance.player.uid)
{
MultiBattleProxy.Instance.SendStatus("Idle", m_HashIdle.ToString());
}
}
///
/// 冲刺攻击消息
///
///
public void OnMsg_DashAttack(Rush_MsgData data)
{
SetAnimatorStatusDash(data);
// 网络同步
if (GameDateManager.Instance.isMultiRoom && playerUID == UserProxy.Instance.player.uid)
{
string msgData = CommonManager.Serialize(data);
MultiBattleProxy.Instance.SendStatus("DashAttack", m_HashDashAttack.ToString());
}
}
///
/// 闪避消息
///
///
public void OnMsg_Dodge(Dodge_MsgData data)
{
isGod = true;
m_GodTime = 0.5f;
////if (m_CurState != eState.Idle)
{
SetAnimatorStatusRush();//触发前冲闪避
}
////else
////{
//// SetAnimatorStatusDodge();//触发后退闪避动作
////}
data.dir.Normalize();
//if (isExtermeTimeZone)//极限闪避
//{
// SetExtermeDodgeTimer(10);
//}
}
public void OnMsg_Bisha(Dodge_MsgData data)
{
SetAnimatorStatusSkill();
}
///
/// 技能消息
///
///
public void OnMsg_Skill(Skill_MsgData data)
{
m_Rigidbody.velocity = Vector3.zero;//刚体推力设置为0
SetAnimatorStatusSkill();
data.dir.Normalize();
transform.rotation = Quaternion.LookRotation(data.dir);//看向方向
if (m_targetMonster)
{
LockingTarget();//锁定目标
}
m_CurState = eState.Skill;
}
///
/// 受击消息接收
///
///
public override void OnMsg_Attacked(Attacked_MsgData data)
{
Debug.Log("英雄受击消息");
//m_targetMonster = data.sender;
m_ForceDirection = data.forceDirection;
//计算怪角度偏移
float HitAngle = PlayerHelperAdon.Angle_360(transform.forward, m_ForceDirection);
HpbarManager.Instance.CreateHpTip(this, data.dmg, data.isCR, data.weakness);//血条及数字显示
if (data.resultHp <= 0)//死亡
{
if (data.attackedEffType == EnumDefine.AttackedEffT.DWN)//击倒击飞
{
SetCameraShake(transform.position, 2f, 0.1f, 0.3f);//震屏
m_Animator.SetTrigger(hashDieDown);//播放击飞死亡动作
//转向玩家
transform.LookAt(data.sender.transform);
}
else
{
m_Animator.SetTrigger(hashDie);//播放死亡动作
SetCameraShake(transform.position, 0.8f, 0.1f, 0.2f);//震屏
}
// 英雄死亡
HeroDie();
}
else
{
if (data.dmg < 0)
{
if (data.attackedEffType == EnumDefine.AttackedEffT.DWN)//击倒击飞
{
SetCameraShake(transform.position, 2f, 0.1f, 0.3f);//震屏
m_Animator.SetTrigger(hashHitDown);//播放击倒动作
transform.LookAt(data.sender.transform);
}
else if (data.attackedEffType == EnumDefine.AttackedEffT.NOR)
{
SetCameraShake(transform.position, 0.8f, 0.1f, 0.2f);//震屏
}
else
{
m_Animator.SetTrigger(hashHit);//播放受击动作
m_Animator.SetFloat(hashHitAngle, HitAngle);//根据受击方向播受击动作
SetCameraShake(transform.position, 0.8f, 0.1f, 0.2f);//震屏
}
}
}
//实例化克隆被击光效
if (data.AttackedEff != null)
{
GameObject effobj = Instantiate(data.AttackedEff);
if (!effobj.GetComponent()) effobj.gameObject.AddComponent();//添加延迟销毁脚本
effobj.transform.position = m_HitObj.position;
if (m_targetMonster != null)
{
effobj.transform.rotation = m_targetMonster.transform.rotation;
}
effobj.SetActive(true);
}
if (data.SkillId == "711002" || data.SkillId == "708003" || data.dmg > 0)
{
//m_damageFlash.gameObject.SetActive(true);//受击高亮材质显示
//m_damageFlashScale = 5;
//for (int l = 0; l < m_damageFlashMaterial.Length; l++)
//{
// m_damageFlashMaterial[l].SetFloat("_Scale", m_damageFlashScale);
//}
m_freezeFlashs.gameObject.SetActive(true);
//m_freezeFlashPower = 5;
for (int l = 0; l < m_freezeFlashMaterial.Length; l++)
{
m_freezeFlashMaterial[l].SetFloat("_Power", 0.6f);
}
}
else
{
m_damageFlash.gameObject.SetActive(true);//受击高亮材质显示
m_damageFlashScale = 5;
for (int l = 0; l < m_damageFlashMaterial.Length; l++)
{
m_damageFlashMaterial[l].SetFloat("_Scale", m_damageFlashScale);
}
}
isAttacked = true;
isGod = true;
m_GodTime = 0.5f;
}
///
/// 英雄死亡
///
private void HeroDie()
{
// 延迟删除角色
RoleManager.Instance.DeleteRole(this, 2.0f);
GameDateManager.Instance.PlayerDeathNumber++;
HeroPlayerController.Instance.m_Hero.TargetRole = null;
// 队长死亡
if (IsTeamLeader)
{
GameDateManager.Instance.PlayerDeathNumber++;
// 切换下一位队长
RoleManager.Instance.NextTeamLeader(transform.position, (suc) =>
{
if (suc == false)
{
if (YLBattle.GameBattleManager.Instance().battleType == BattleDefine.EBattleSceneType.EBattleType_Arena)
{
RoleManager.Instance.ChallengeResult(false);
}
else
{
// 切换队长失败,游戏结束
PanelHelper.Instance.ShowPanel("YL_BattleFailWindow", null, null);
}
}
});
}
}
///
/// 治愈消息接收
///
///
public void OnMsg_Curing(Attacked_MsgData data)
{
Debug.Log("英雄治愈消息");
//m_targetMonster = data.sender;
m_ForceDirection = data.forceDirection;
//计算怪角度偏移
float HitAngle = PlayerHelperAdon.Angle_360(transform.forward, m_ForceDirection);
HpbarManager.Instance.CreateHpTip(this, data.dmg, data.isCR, data.weakness);//血条及数字显示
//实例化克隆被击光效
if (data.AttackedEff != null)
{
GameObject effobj = Instantiate(data.AttackedEff);
if (!effobj.GetComponent()) effobj.gameObject.AddComponent();//添加延迟销毁脚本
effobj.transform.position = m_HitObj.position;
effobj.transform.rotation = this.transform.rotation;
effobj.SetActive(true);
}
m_CuringFlashs.gameObject.SetActive(true);//治愈高亮材质显示
m_CuringFlashScale = 5;
for (int l = 0; l < m_CuringFlashMaterial.Length; l++)
{
m_CuringFlashMaterial[l].SetFloat("_Scale", m_CuringFlashScale);
}
isCuring = true;
}
/////
///// 战士普通打击
/////
/////
/////
//public void OnMsgAttackHit(WarReportInfo report)
//{
// WarReportUnit enemyData = report.UnitDataTarget[0];
// BaseMonsterAdon enemy = RoleManager.Instance.GetRole(enemyData.UnitId) as BaseMonsterAdon;
// //m_targetMonster = enemy.gameObject;
// //僵直一下
// //m_clockRoot.localTimeScale = 0.01f;
// //特效时钟暂停
// stiffTime += 0.05f;
// if (stiffTime > 0.3f)
// {
// stiffTime = 0.3f;
// }
// isStiff = true;
// Attacked_MsgData data = new Attacked_MsgData();//受击消息数据
// data.sender = this.gameObject;
// Vector3 force = enemy.transform.position - transform.position;//推力方向
// force.Normalize();
// if (m_CurAttackIdx == 5)
// {
// data.attackedEffType = EnumDefine.AttackedEffT.DWN;
// data.forceDirection = force;//推力方向
// //发送震屏
// //SetCameraShake(transform.position, 2, 0.1f, 0.3f);
// }
// else if (m_CurAttackIdx == 0)
// {
// data.attackedEffType = EnumDefine.AttackedEffT.SLD;
// data.forceDirection = force;//推力方向
// //发送震屏
// //SetCameraShake(transform.position, 2f, 0.1f, 0.3f);
// }
// else
// {
// data.attackedEffType = EnumDefine.AttackedEffT.SLD;
// data.forceDirection = force;//推力方向
// //发送震屏
// //SetCameraShake(transform.position, 0.8f, 0.1f, 0.2f);
// }
// //计算怪剩余血量
// data.resultHp = enemyData.NowData.HP_Final;
// data.dmg = enemyData.DiffData.HP_Final;
// data.isCR = enemyData.NowData.IS_CRT;//是否暴击
// data.AttackedEff = m_FxManagerAdon.m_AttackedEff[m_CurAttackIdx].gameObject;//被击特效
// enemy.OnMsg_Attacked(data);
// if (data.resultHp <= 0)//目标死亡
// {
// //释放目标
// ReleaseTarget();
// }
//}
/////
///// 言灵技能打击
/////
/////
/////
//public void OnMsgYanlingSkill(WarReportInfo report)
//{
// //string OwnerId;//发送者id
// //string TargetId;//目标者id
// //string SkillId;//技能id
// //int resultHP;//剩余血量
// //int dmg;//单次伤害值
// //bool isCR;//是否暴击
// //bool isBuff;//是否为buff
// //int buffType;//buff类型
// //bool isDOG;//是否闪避
// WarReportUnit enemyData = report.UnitDataTarget[0];
// BaseMonsterAdon enemy = RoleManager.Instance.GetRole(enemyData.UnitId) as BaseMonsterAdon;
// Attacked_MsgData data = new Attacked_MsgData();//受击消息数据
// data.sender = this.gameObject;
// Vector3 force = enemy.transform.position - transform.position;//推力方向
// force.Normalize();
// //判断技能id
// if (m_CurAttackIdx == 5)
// {
// data.attackedEffType = EnumDefine.AttackedEffT.DWN;
// data.forceDirection = force;//推力方向
// //发送震屏
// //SetCameraShake(transform.position, 2, 0.1f, 0.3f);
// }
// else if (m_CurAttackIdx == 0)
// {
// data.attackedEffType = EnumDefine.AttackedEffT.SLD;
// data.forceDirection = force;//推力方向
// //发送震屏
// //SetCameraShake(transform.position, 2f, 0.1f, 0.3f);
// }
// else
// {
// data.attackedEffType = EnumDefine.AttackedEffT.SLD;
// data.forceDirection = force;//推力方向
// //发送震屏
// //SetCameraShake(transform.position, 0.8f, 0.1f, 0.2f);
// }
// //计算怪剩余血量
// data.resultHp = enemyData.NowData.HP_Final;
// data.dmg = enemyData.DiffData.HP_Final;
// data.isCR = enemyData.NowData.IS_CRT;//是否暴击
// data.AttackedEff = m_FxManagerAdon.m_AttackedEff[m_CurAttackIdx].gameObject;//被击特效
// enemy.OnMsg_Attacked(data);
// if (data.resultHp <= 0)//目标死亡
// {
// //释放目标
// ReleaseTarget();
// }
//}
/////
///// Debuff打击发动
/////
/////
/////
//public void OnMsgDebuff(WarReportInfo report)
//{
// Attacked_MsgData data = new Attacked_MsgData();//受击消息数据
// data.buffType = report.BuffDataInfo.mo.buffType;
// data.valueMove = report.BuffDataInfo.mo.moveSpeed;
// data.dmg = (int)report.BuffDataInfo.mo.damage;
// data.sender = this.gameObject;
// ///根据触发的技能id获取触发的言灵挂件
// ///获取挂件技能的被动技
// //data.AttackedEff = m_FxManagerAdon.m_AttackedEff[m_CurAttackIdx].gameObject;//被击特效
// WarReportUnit enemyData = report.UnitDataTarget[0];
// BaseMonsterAdon enemy = RoleManager.Instance.GetRole(enemyData.UnitId) as BaseMonsterAdon;
// enemy.OnMsgDebuff(data);
// if (data.resultHp <= 0)//目标死亡
// {
// //释放目标
// ReleaseTarget();
// }
//}
public Attacked_MsgData m_Attacked_MsgData;
public BaseCharacterAdon m_Enemy;
//----------------------新战报方法
///
/// 新战士普通打击
///
///
///
public void OnMsgAttackHitNew(ReportDataAdon report)
{
m_Enemy = null;
if (report.targetUnitType == EBattleUnitType.Hero)
{
m_Enemy = RoleManager.Instance.GetRole(report.TargetId) as BaseHero;
}
else
{
m_Enemy = RoleManager.Instance.GetRole(report.TargetId) as BaseMonsterAdon;
}
//BaseMonsterAdon enemy = RoleManager.Instance.GetRole(report.TargetId) as BaseMonsterAdon;
m_Attacked_MsgData = new Attacked_MsgData();//受击消息数据
m_Attacked_MsgData.sender = this.gameObject;
Vector3 force = m_Enemy.transform.position - transform.position;//推力方向
m_Attacked_MsgData.HitAngle = 180;
force.Normalize();
if (m_CurAttackIdx == 5)
{
m_Attacked_MsgData.attackedEffType = EnumDefine.AttackedEffT.DWN;
m_Attacked_MsgData.forceDirection = force;//推力方向
}
else if (m_CurAttackIdx == 0)//冲刺攻击
{
m_Attacked_MsgData.attackedEffType = EnumDefine.AttackedEffT.SLD;
m_Attacked_MsgData.forceDirection = force;//推力方向
}
else
{
m_Attacked_MsgData.attackedEffType = EnumDefine.AttackedEffT.SLD;
m_Attacked_MsgData.forceDirection = force;//推力方向
//发送震屏
//SetCameraShake(transform.position, 0.8f, 0.1f, 0.2f);
}
//计算怪剩余血量
m_Attacked_MsgData.resultHp = report.resultHP;
m_Attacked_MsgData.dmg = report.dmg;
m_Attacked_MsgData.isCR = report.isCR;//是否暴击
m_Attacked_MsgData.weakness = report.weakness;
m_Attacked_MsgData.AttackedEff = m_FxManagerAdon.m_AttackedEff[m_CurAttackIdx].gameObject;//被击特效
if (m_Attacked_MsgData.resultHp <= 0)//目标死亡
{
//释放目标
ReleaseTarget();
}
OnMsgAttackHitNewExpand(report);
m_Enemy.OnMsg_Attacked(m_Attacked_MsgData);
}
///
/// 新战士普通打击拓展
///
///
public virtual void OnMsgAttackHitNewExpand(ReportDataAdon report)
{
}
float m_stopTime;
bool m_bStopTime;
float lastUpdateTime;
public void HITStop(float stopTime)
{
m_stopTime = stopTime;
m_bStopTime = true;
lastUpdateTime = Time.realtimeSinceStartup;
Time.timeScale = 0;
}
///
/// 言灵技能打击
///
///
///
public void OnMsgYanlingSkillNew(ReportDataAdon report)
{
Debug.Log("新言灵技战报触发");
Role target = RoleManager.Instance.GetRole(report.TargetId);
Attacked_MsgData data = new Attacked_MsgData();//受击消息数据
data.sender = this.gameObject;
Vector3 force = target.transform.position - transform.position;//推力方向
force.Normalize();
data.resultHp = report.resultHP;
data.dmg = report.dmg;
data.isCR = report.isCR;//是否暴击
data.weakness = report.weakness;
//获取言灵挂件被击特效
//BaseYLPartAdon YLPart = report.YLPart.GetComponent();
//data.AttackedEff = YLPart.m_FxManagerAdon.m_AttackedEff[m_CurAttackIdx].gameObject;//被击特效
data.SkillId = report.SkillId;
//判断技能id
if (data.SkillId == "6010201" || data.SkillId == "6010301")
{
data.attackedEffType = EnumDefine.AttackedEffT.STF;
data.forceDirection = Vector3.zero;//推力方向
}
else if (data.SkillId == "6010302")//星云吸力
{
data.attackedEffType = EnumDefine.AttackedEffT.INHALE;
data.forceDirection = Vector3.zero;//推力方向
}
else
{
data.attackedEffType = EnumDefine.AttackedEffT.SLD;
data.forceDirection = force;//推力方向
}
if (data.resultHp <= 0)//目标死亡
{
//释放目标
ReleaseTarget();
}
if (report.targetUnitType == EBattleUnitType.Hero)
{
BaseHero hero = target as BaseHero;
hero.OnMsg_Curing(data);//治愈
}
else
{
BaseMonsterAdon enemy = target as BaseMonsterAdon;
enemy.OnMsg_Attacked(data);
}
}
///
/// Debuff打击发动
///
///
///
public void FireMsgDebuffNew(ReportDataAdon report)
{
Debug.Log("新Debuff战报触发");
Attacked_MsgData data = new Attacked_MsgData();//受击消息数据
data.buffType = report.buffType;
//data.valueMove = report.BuffDataInfo.mo.moveSpeed;
data.dmg = report.dmg;
data.resultHp = report.resultHP;
data.sender = this.gameObject;
data.buffResStr = report.buffData.mo.res;
data.buffPoi = report.buffData.mo.bullet_attack_poi;
///根据触发的技能id获取触发的言灵挂件
///获取挂件技能的被动光效
//获取挂件技能的死亡光效
//BaseYLPartAdon part = GetYLPart(report.SkillId);
//if(part != null)
//{
// data.AttackedEff = part.GetAttackedEff().gameObject;
// data.DieEff = part.GetDieEff().gameObject;
//}
BaseMonsterAdon enemy = RoleManager.Instance.GetRole(report.TargetId) as BaseMonsterAdon;
if (enemy != null)
{
enemy.OnMsgDebuff(data);
}
BaseHero play = RoleManager.Instance.GetRole(report.TargetId) as BaseHero;
if (play != null)
{
play.OnMsgDebuff(data);
}
if (data.resultHp <= 0)//目标死亡
{
//释放目标
ReleaseTarget();
//根据技能id获取挂件
//获取挂件的死亡特效
//赋值死亡特效
}
}
///
/// 执行debuff
///
///
public void OnMsgDebuff(Attacked_MsgData data)
{
int damage;
//debuff计数
if (buffnum.ContainsKey(data.buffType))
{
int num = buffnum[data.buffType];
num++;
buffnum[data.buffType] = num;
}
else
{
buffnum[data.buffType] = 1;
}
//1眩晕 2静止 3护盾 4沉默 5麻痹 6灼烧 7冰冻 8黯
switch (data.buffType)
{
case 1:
//眩晕,播放眩晕动作,显示眩晕光效,禁用玩家控制
m_FxManagerAdon.m_DizzEff.gameObject.SetActive(true);
HeroPlayerController.Instance.SetInputBlocked(true);//禁用控制
HeroPlayerController.Instance.SetAutoMoveDirection(Vector2.zero);
isStun = true;
m_Animator.SetBool(hashStun, true);
break;
case 5:
damage = data.dmg;
///执行debuff
///麻痹
SetLocalClockTimeScale(0.1f);
HpbarManager.Instance.CreateHpTip(this, -damage, false, 1.0f);//血条及数字显示
break;
case 6:
damage = data.dmg;
///灼烧
HpbarManager.Instance.CreateHpTip(this, -damage, false, 1.0f);//血条及数字显示
break;
case 7:
damage = data.dmg;
///执行debuff
///缓速
///冻结效果
SetLocalClockTimeScale(0.3f);
//开启冻结网格材质
m_freezeFlashs.gameObject.SetActive(true);
//m_freezeFlashPower = 5;
for (int l = 0; l < m_freezeFlashMaterial.Length; l++)
{
m_freezeFlashMaterial[l].SetFloat("_Power", 0.6f);
}
HpbarManager.Instance.CreateHpTip(this, -damage, false, 1.0f);//血条及数字显示
break;
case 8:
damage = data.dmg;
///中毒
HpbarManager.Instance.CreateHpTip(this, -damage, false, 1.0f);//血条及数字显示
break;
}
if (data.resultHp <= 0)//死亡
{
m_Animator.SetTrigger(hashDie);
// 英雄死亡
HeroDie();
}
}
///
/// 关闭debuff
///
///
public void OffMsgDebuff(ReportDataAdon reportData)
{
//debuff计数减
if (buffnum.ContainsKey(reportData.buffType))
{
int num = buffnum[reportData.buffType];
num--;
buffnum[reportData.buffType] = num;
if (buffnum[reportData.buffType] > 0) return;
}
//1眩晕 2静止 3护盾 4沉默 5麻痹 6灼烧 7冰冻 8黯
switch (reportData.buffType)
{
case 1:
//眩晕,播放眩晕动作,显示眩晕光效,禁用玩家控制
m_FxManagerAdon.m_DizzEff.gameObject.SetActive(false);
HeroPlayerController.Instance.SetInputBlocked(false);//禁用控制
isStun = false;
m_Animator.SetBool(hashStun, false);
break;
case 5:
SetLocalClockTimeScale(1);
break;
case 7:
SetLocalClockTimeScale(1);
for (int l = 0; l < m_freezeFlashMaterial.Length; l++)
{
m_freezeFlashMaterial[l].SetFloat("_Power", 2.5f);
}
m_freezeFlashs.gameObject.SetActive(false);
break;
}
}
#endregion
//#endregion
///
/// 锁定目标
///
void LockingTarget()
{
if (m_targetMonster)
{
BaseMonsterAdon targetM = m_targetMonster.GetComponent();
if (targetM == null || targetM.m_HitObj == null)
{
return;
}
//Debug.Log("锁定目标");
if (m_targetMonster.GetComponent().m_CurState == eState.Die) return;
//m_CameraManagerAdon.SetLockTarget(targetMonster);//相机添加锁定目标
GameObject lookTarget = targetM.m_HitObj.gameObject;
m_PerfectLookAtAdon.m_TargetObject = lookTarget;//甚至看向对目标对象
isHeadlook = true;
}
}
void ReleaseTarget()
{
//m_CameraManagerAdon.ReleaseTarget();//相机释放锁定目标
m_PerfectLookAtAdon.m_TargetObject = null;
isHeadlook = false;
//ObjectManagerAdon.RemoveMonster(targetMonster.GetComponent().Name, targetMonster);
//m_targetMonster = null;
}
///
/// 设置可极限闪避时区
///
/// 可极限闪避的倒计时
public void SetExtermeTimeZone(float _time)
{
m_ExtermeZoneTimer = _time;
isExtermeTimeZone = true;
}
///
/// 设置极限闪避计时
///
/// 可极限闪避的倒计时
public void SetExtermeDodgeTimer(float _time)
{
m_ExtermeDodgeTimer = _time;
isExtermeDodge = true;
//全部慢放
m_clockEnemy.localTimeScale = 0.1f;
m_clockPlayer.localTimeScale = 0.1f;
m_CameraManagerAdon.PlyeExterme();
}
///
/// 释放极限闪避效果
///
private void FreedExterme()
{
m_clockEnemy.localTimeScale = 1;
m_CameraManagerAdon.StopExterme();
}
///
/// 设置无敌免伤
///
/// 免伤时间
public void SetGod(float godTime)
{
isGod = true;
m_GodTime = godTime;
}
///
/// 发动言灵技
///
///
public void BattleUseYanlingSkill(string id, X2Battle.EBulletCastPoint point)
{
if (isStun == true) return;
///播放言灵挂件攻击动作
if (point == EBulletCastPoint.ECAST_POINT_HEAD)
{
m_Head_YL.m_CurUseSkill = id;
m_Head_YL.OnFire();
_Head_YL.M_YLType = point;
m_YLParts[id] = m_Head_YL;
}
else if (point == EBulletCastPoint.ECAST_POINT_SHOULDER)
{
m_Shoulder_YL.m_CurUseSkill = id;
m_Shoulder_YL.OnFire();
m_Shoulder_YL.M_YLType = point;
m_YLParts[id] = m_Shoulder_YL;
}
else if (point == EBulletCastPoint.ECAST_POINT_FOOT)
{
m_Foot_YL.m_CurUseSkill = id;
m_Foot_YL.OnFire();
m_Foot_YL.M_YLType = point;
m_YLParts[id] = m_Foot_YL;
}
LockingTarget();
}
///
/// 取消言灵技
///
///
public void BattleCancelyanlingSkill(string id, X2Battle.EBulletCastPoint point)
{
Debug.Log(id);
///播放言灵挂件攻击动作
if (point == EBulletCastPoint.ECAST_POINT_HEAD)
{
//m_Head_YL.m_CurUseSkill = "";
m_Head_YL.OffFire();
}
else if (point == EBulletCastPoint.ECAST_POINT_SHOULDER)
{
//m_Shoulder_YL.m_CurUseSkill = "";
m_Shoulder_YL.OffFire();
//m_Foot_YL.OnFire();//测试
}
else if (point == EBulletCastPoint.ECAST_POINT_FOOT)
{
//m_Foot_YL.m_CurUseSkill = "";
m_Foot_YL.OffFire();
}
//LockingTarget();
}
///
/// 获取言灵部件
///
///
///
public BaseYLPartAdon GetYLPart(string skillId)
{
if (m_YLParts.Count > 0 && m_YLParts.ContainsKey(skillId))
{
return m_YLParts[skillId];
}
return null;
}
///
/// 播放胜利
///
public void PlayWinning()
{
m_Animator.SetTrigger(hashWin);
m_CameraManagerAdon.SwitchToCM_Win();
m_CurState = eState.Win;
}
///
/// 是否可伤害
///
///
public bool IsHurt()
{
if (isGod || m_CurState == eState.Die || m_CurState == eState.Win)
{
return false;
}
return true;
}
float attackNum = 1;
bool bDodge = false;
//---------------------------FBXEvent------------------------------------
///
/// 攻击移动开始
///
public void OnAttackMoveStart(float num)
{
attackNum = num;
//更改为寻路方式冲刺
if (m_CurState == eState.DashAttack)
{
m_navMeshAgent.component.destination = m_targetMonster.transform.position;
m_navMeshAgent.component.speed = 10;
}
else
{
//HeroPlayerController.Instance.moveController.SetMoveOff();//关闭控制器移动
// 闪避
if (bDodge)
{
bDodge = false;
// 推力
Vector3 velocity = transform.forward * attackNum;
m_Rigidbody.velocity = velocity;
}
}
}
///
/// 显示攻击范围
///
public void ShowAttackRange()
{
// 推力
if (m_CurState != eState.Skill && m_Rigidbody.velocity.magnitude == 0)
{
Vector3 velocity = transform.forward.normalized * attackNum;
m_Rigidbody.velocity = velocity;
}
if (attackRangeTran)
{
//attackRangeTran.localScale = Vector3.one * (m_WeaponCol as SphereCollider).radius * 2;
attackRangeTran.localScale = Vector3.one * 5;
attackRangeTran.gameObject.SetActive(true);
if (IsInvoking("HideAttackRange"))
{
CancelInvoke("HideAttackRange");
}
Invoke("HideAttackRange", 1.0f);
}
}
///
/// 隐藏攻击范围
///
public void HideAttackRange()
{
CancelInvoke("ShowAttackRange");
if (attackRangeTran)
{
attackRangeTran.gameObject.SetActive(false);
}
}
///
/// 击飞移动开始
///
public void OnDownMoveStart(float num)
{
//HeroPlayerController.Instance.moveController.SetMoveOff();//关闭控制器移动
Vector3 velocity = m_ForceDirection * num;
m_Rigidbody.velocity = velocity;
}
///
/// 击飞移动结束
///
public void OnDownMoveEnd()
{
HeroPlayerController.Instance.moveController.SetMoveOn();//开启控制器移动
m_Rigidbody.velocity = Vector3.zero;
}
public void OnAttackMoveEnd()
{
HeroPlayerController.Instance.moveController.SetMoveOn();//开启控制器移动
m_Rigidbody.velocity = Vector3.zero;
m_navMeshAgent.component.ResetPath();
m_navMeshAgent.component.speed = 5;
}
///
/// 普通攻击触发
///
/// 技能id
/// 子连击id
public virtual void OnAttackOn(string attackId)
{
// 检测是否有怪物
Collider[] colliders = Physics.OverlapSphere(transform.position, 2.5f, 1 << LayerMask.NameToLayer("Enemy"));
bool showAttackRange = true;
for (int i = 0; i < colliders.Length; i++)
{
// 筛选符合攻击范围的玩家
Vector3 v3Dir = colliders[i].transform.position - transform.position;
v3Dir.Normalize();
float angle = Vector3.Angle(transform.forward, v3Dir);
if (angle <= 70)
{
showAttackRange = false;
break;
}
}
if (showAttackRange)
{
ShowAttackRange();
}
List list = new List(attackId.Split(','));
m_SkillId = int.Parse(list[0]);
if (list.Count > 1)
{
m_CurAttackIdx = int.Parse(list[1]);
}
else
{
m_CurAttackIdx = 1;
}
if (m_SkillId == 1)
{
m_WeaponCol.transform.localEulerAngles = Vector3.zero;
m_WeaponCol.enabled = true;
}
else if (m_SkillId == 2)
{
m_SkillCol.transform.localEulerAngles = Vector3.zero;
m_SkillCol.enabled = true;
}
}
///
/// 普通攻击结束
///
public void OnAttackOff()
{
if (m_WeaponCol) m_WeaponCol.enabled = false;//关闭武器碰撞
if (m_SkillCol) m_SkillCol.enabled = false;//关闭技能碰撞
}
///
/// 受击移动开始
///
public void OnHitMoveStart(float force)
{
Vector3 velocity = m_ForceDirection * force;
m_Rigidbody.velocity = velocity;
}
///
/// 受击移动结束
///
public void OnHitMoveEnd()
{
m_Rigidbody.velocity = Vector3.zero;
}
///
/// 释放残影
///
public void OnHeroBlur()
{
m_HeroBlur.enabled = false;
m_HeroBlur.enabled = true;
}
///
/// 武器技能触发事件
///
///
void OnTriggerEnter(Collider collision)
{
if (collision.gameObject.layer == LayerMask.NameToLayer("Obstacle"))//层
{
Debug.Log("碰撞陷阱");
m_CapsuleCollider.isTrigger = false;
}
}
#if UNITY_EDITOR
///
/// 绘制打击配置
///
private void OnDrawGizmosSelected()
{
Vector3 forward = transform.forward;
UnityEditor.Handles.color = new Color(1.0f, 0.0f, 0.0f, 0.1f);
Vector3 rotatedForward = Quaternion.Euler(0, -m_AttackAngle * 0.5f, 0) * transform.forward;
UnityEditor.Handles.DrawSolidArc(transform.position, Vector3.up, rotatedForward, m_AttackAngle, m_AttackSight);
UnityEditor.Handles.color = new Color(0.0f, 1.0f, 0.0f, 0.1f);
UnityEditor.Handles.DrawSolidArc(transform.position, transform.up, forward, 360, m_AutoAttackRange);
}
#endif
}
}