/// <summary>
/// 获取技能的cd时间
/// </summary>
/// <param name="skill_id"></param>
/// <returns></returns>
public uint GetCD(uint skill_id)
{
uint cd_life_time = 0;
if (m_SkillCDInfo.TryGetValue(skill_id, out cd_life_time))
{
return(cd_life_time);
}
else// 服务端数据中没有则从表格中获取
{
DBSkillSev skill_db = DBManager.GetInstance().GetDB <DBSkillSev>();
if (skill_db == null)
{
GameDebug.LogError("skill database not exsit!");
return(0);
}
DBSkillSev.SkillInfoSev skill_info = skill_db.GetSkillInfo(skill_id);
if (skill_info == null)
{
GameDebug.LogError("skillInfo is null! type_idx: " + skill_id);
return(0);
}
else
{
return((uint)UnityEngine.Mathf.Max(skill_info.CDTime, 0));
}
}
}
/// <summary>
/// 是否处于不可攻击状态
/// </summary>
public bool IsAttackDisable(uint skillId)
{
if (IsMonster == true)
{
return(false);
}
if (FlagOperate.HasFlag(mCurBattleState, (int)BattleStatusType.BATTLE_STATUS_TYPE_SAttakcDisableBase))
{
return(true);
}
DBSkillSev.SkillInfoSev infoSev = DBManager.Instance.GetDB <DBSkillSev>().GetSkillInfo(skillId);
if (infoSev != null)
{
if (infoSev.IsPg)
{
return(FlagOperate.HasFlag(mCurBattleState, (int)BattleStatusType.BATTLE_STATUS_TYPE_BLIND));
}
else
{
if (FlagOperate.HasFlag(mCurBattleState, (int)BattleStatusType.BATTLE_STATUS_TYPE_BLIND))
{
return(true);
}
else if (FlagOperate.HasFlag(mCurBattleState, (int)BattleStatusType.BATTLE_STATUS_TYPE_BLIND2))
{
return(true);
}
}
}
return(false);
}
/// <summary>
/// 销毁GameObject前要进行的操作
/// </summary>
public void DestroyAll()
{
mThunderHitInfo = null;
m_HitCallback = null;
m_SkillInfo = null;
EffectManager.GetInstance().RemoveSkillInstance(mID);
if (mEffectBaseComponent != null)
{
mEffectBaseComponent.DestroyAll();
}
}
bool mHideEffect = false; // 是否隐藏子弹特效
/// <summary>
/// 初始化
/// </summary>
public bool Init()
{
m_SkillInfo = DBSkillSev.Instance.GetSkillInfo(SkillID);
m_SubEmitId = (ulong)(((ulong)ActorID << 32 & 0xffffffff00000000) | ((ulong)SkillID << 16 & 0xffffffffffff0000)); // 暂时使用技能ID和角色ID来进行组合
if (m_SkillInfo != null && m_SkillInfo.BulletId != 0)
{
m_BulletInfo = DBBulletTrace.GetInstance().GetBulletInfo(m_SkillInfo.BulletId);
if (m_BulletInfo != null)
{
if (HitPlayers.Count > 0)
{
uint hit_player_id = HitPlayers[0];
Actor src_player = ActorManager.Instance.GetPlayer(ActorID);
Actor hitPlayer = ActorManager.Instance.GetPlayer(hit_player_id);
if (src_player == null || hitPlayer == null || src_player.GetActorMono() == null || hitPlayer.GetActorMono() == null)
{
return(false);
}
ActorMono src_actormono = src_player.GetActorMono();
ActorMono hit_actormono = hitPlayer.GetActorMono();
BulletTrackInstance sub_bullet_trace = new xc.BulletTrackInstance(m_BulletInfo, m_SkillInfo, 0);
m_TraceInsts.Add(sub_bullet_trace);
// 开启新的BulletTrackInstance
mHideEffect = ShieldManager.Instance.IsHideBulletEffect(src_player, hitPlayer);
sub_bullet_trace.Do(m_SubEmitId, src_actormono, hit_actormono, mHideEffect, src_player.transform.position, src_player.transform.rotation, src_player.transform.forward, OnHit);
// 将伤害信息添加到新创建的SkillAttackInstance列表中
SkillAttackInstance attack_inst = EffectManager.GetInstance().GetAttackInstance(m_SubEmitId);
if (attack_inst != null)
{
Damage dmgInfo = null;
if (m_DamageInfos.TryGetValue(hit_player_id, out dmgInfo))
{
attack_inst.AddHurtInfo(dmgInfo);
}
}
m_HitEmits[hit_player_id] = new HitCacheInfo(m_SubEmitId);
m_SubEmitId++;
mLastThunderPlayer = hit_player_id;
HitPlayers.RemoveAt(0);
return(true);
}
}
}
return(false);
}
public static SkillData CreateSkillData(DBSkillSev.SkillInfoSev info)
{
SkillData skill_data = new SkillData();
skill_data.SkillID = info.Id;
skill_data.SkillParentID = info.ParentSkillId;
skill_data.SkillActionList = new List <SkillActionData>();
var action_data = SkillActionData.CreateSkillActionData(info);
skill_data.SkillActionList.Add(action_data);
return(skill_data);
}
public static SkillActionData CreateSkillActionData(DBSkillSev.SkillInfoSev info)
{
SkillActionData skill_action_data = new SkillActionData();
skill_action_data.SkillInfo = info;
skill_action_data.SkillAnimation = info.AnimationName;
skill_action_data.CastingAnimation = info.CastingAnimationName;
skill_action_data.CastingReadyAnimation = info.CastingReadyName;
skill_action_data.CastingEndAnimation = info.CastingEndAnimationName;
skill_action_data.RigidityTime = info.RigidityTime;
skill_action_data.CacheTime = info.CacheTime;
// 计算各阶段时间
skill_action_data.CalcTimePoint(1.0f);
return(skill_action_data);
}
/// <summary>
/// 初始化
/// </summary>
public void Init(ulong id, UnitID actor_id, DBSkillSev.SkillInfoSev skill_info, float forwardTime, float totalTime, float attack_speed, SkillBaseComponent AnimationTriggerOption, Action <SkillAttackInstance> hit_callback)
{
mID = id;
m_SrcActorID = actor_id;
m_SkillInfo = skill_info;
mForwardTime = forwardTime;
mfTimeCount = totalTime;
if (mForwardTime > mfTimeCount)
{
mForwardTime = mfTimeCount;
GameDebug.LogError("[SkillAttackInstance]前摇时间大于总时间");
}
mAttackSpeed = attack_speed;
mfElapseTime = 0.0f;
mEffectBaseComponent = AnimationTriggerOption;
m_HitCallback = hit_callback;
m_HasHited = false;
Update();
}
/// <summary>
/// 销毁
/// </summary>
void Destroy()
{
SkillAttackInst.DestroyAll();
SkillAttackInst = null;
foreach (var bullet_trace in m_TraceInsts)
{
var skill_attack_id = bullet_trace.SkillAttackId;
var attack_instance = EffectManager.Instance.GetAttackInstance(skill_attack_id);
if (attack_instance != null)
{
attack_instance.DestroyAll();
}
}
m_TraceInsts.Clear();
// 有可能有没有表现的受击效果
foreach (var damg in m_DamageInfos.Values)
{
if (damg != null)
{
damg.HitEffect();
}
}
m_DamageInfos.Clear();
foreach (var item in m_DeathAppendInfos.Values)
{
if (item != null)
{
Actor actor = ActorManager.Instance.GetActor(item.Id);
if (actor != null)
{
actor.Kill();
}
}
}
m_DeathAppendInfos.Clear();
m_SkillInfo = null;
m_BulletInfo = null;
HitPlayers.Clear();
m_HitEmits.Clear();
}
public BulletTrackInstance(DBBulletTrace.BulletInfo bulllet_info, DBSkillSev.SkillInfoSev skill_info, float delayTime = -1.0f)
{
m_BulletInfo = bulllet_info;
m_SkillInfo = skill_info;
if (delayTime < 0)
{
if (m_SkillInfo.BattleFxInfo != null)
{
m_DelayTime = m_SkillInfo.BattleFxInfo.HitDelayTime;
}
else
{
m_DelayTime = 0.1f;
GameDebug.LogError(string.Format("skill, id: {0} has not battlefx info.", m_SkillInfo.Id));
}
}
else
{
m_DelayTime = delayTime;
}
}
/// <summary>
/// 从技能信息中获取cd时间
/// </summary>
public void Init(uint skill_id, float skillCDReduce)
{
type_idx = skill_id;
time = 0;
DBSkillSev skill_db = DBManager.GetInstance().GetDB <DBSkillSev>();
if (skill_db == null)
{
GameDebug.LogError("skill database not exsit!");
return;
}
DBSkillSev.SkillInfoSev skill_info = skill_db.GetSkillInfo(type_idx);
if (skill_info == null)
{
GameDebug.LogError("skillInfo is null! type_idx: " + type_idx);
}
else
{
life_time = (uint)(Mathf.Max(skill_info.CDTime, 0) * (1f - skillCDReduce));
}
}
public void InitFalseHitBack(Damage dam)
{
if (mOwner == null || mOwner.transform == null)
{
return;
}
if (mOwner is Player)
{
return;
}
DBSkillSev.SkillInfoSev info_sev = DBManager.Instance.GetDB <DBSkillSev>().GetSkillInfo(dam.SkillID);
if (info_sev == null || info_sev.IsFalseHitBack == false)
{
return;
}
ForceStopFalseHitBack();
Actor attacker = ActorManager.Instance.GetActor(dam.SrcID);
Vector3 hitBackForward;
if (attacker != null && attacker.transform != null)
{
hitBackForward = (mOwner.transform.position - attacker.transform.position).normalized;
}
else if (mOwner != null && mOwner.transform != null)
{
hitBackForward = -mOwner.transform.forward;
}
else
{
return;
}
mbFalseHitBackStartPos = mOwner.transform.position; //假击退的起点
mbFalseHitBackDestPos = mbFalseHitBackStartPos + hitBackForward * 0.5f; //假击退的终点
mbFalseHitBackInterval = 0.15f; //假击退的时长
mbFalseHitBackHasAnimTime = 0; //假击退动画已经进行的时长
mbFlaseHitBack_should = true;
}
/// <summary>
/// 进行命中效果的展示
/// </summary>
IEnumerator HitEffectRoutine()
{
DBSkillSev.SkillInfoSev skillInfo = DBSkillSev.Instance.GetSkillInfo(this.SkillID);
if (skillInfo == null)
{
yield break;
}
// 普通伤害数值，如果有伤害分片，则将其添加到多段伤害的列表中
if (mDamageSplitValues == null)
{
if (skillInfo.MultiHitRatios != null)
{
mDamageSplitValues = new List <int>(skillInfo.MultiHitRatios.Count);
int leave_num = DamageValue;
for (int i = 0; i < skillInfo.MultiHitRatios.Count; ++i)
{
int show_damage = (int)(DamageValue * skillInfo.MultiHitRatios[i]);
if (i == (skillInfo.MultiHitRatios.Count - 1) && leave_num > show_damage)
{
show_damage = leave_num;//最后一下，弥补伤害；防止出现多段伤害：0 + 0，最终伤害是 1 的情况
}
mDamageSplitValues.Add(show_damage);
leave_num -= show_damage;
}
}
else
{
mDamageSplitValues = new List <int>(1);
mDamageSplitValues.Add(DamageValue);
}
}
// 特殊状态的伤害数值，如果有伤害分片，则将其添加到多段状态的列表中
if (this.DamageSpecs != null && mDamageSpecsSplitValues == null)
{
if (skillInfo.MultiHitRatios != null)
{
mDamageSpecsSplitValues = new List <Dictionary <uint, int> >();
for (int i = 0; i < skillInfo.MultiHitRatios.Count; ++i)
{
mDamageSpecsSplitValues.Add(new Dictionary <uint, int>());
}
// 需要进行合并处理的特殊状态(不进行分段显示)
Dictionary <uint, int> combineSpecValues = null;
foreach (var item in DamageSpecs)
{
if (DBDamageEffect.Instance.IsCombineValue(item.Key))
{
if (combineSpecValues == null)
{
combineSpecValues = new Dictionary <uint, int>();
}
combineSpecValues[item.Key] = item.Value;
}
}
//对每一个特殊状态进行分段处理
foreach (var item in DamageSpecs)
{
if (DBDamageEffect.Instance.IsCombineValue(item.Key))
{
continue;
}
uint state_type = item.Key;
int leave_num = item.Value;
for (int i = 0; i < skillInfo.MultiHitRatios.Count; ++i)
{
int show_damage = (int)(item.Value * skillInfo.MultiHitRatios[i]);
if (i == (skillInfo.MultiHitRatios.Count - 1) && leave_num > show_damage)
{
show_damage = leave_num;//最后一下，弥补伤害；防止出现多段伤害：0 + 0，最终伤害是 1 的情况
}
mDamageSpecsSplitValues[i].Add(state_type, show_damage);
leave_num -= show_damage;
}
}
// 将合并的伤害数值添加到最后
if (combineSpecValues != null && mDamageSpecsSplitValues.Count > 0)
{
var last = mDamageSpecsSplitValues.Count - 1;
var lastValues = mDamageSpecsSplitValues[last];
foreach (var item in combineSpecValues)
{
lastValues[item.Key] = item.Value;
}
}
}
else
{
mDamageSpecsSplitValues = new List <Dictionary <uint, int> >(1);
mDamageSpecsSplitValues.Add(DamageSpecs);
}
}
if (mDamageSplitValues.Count <= 0)
{
GameDebug.LogError("HitEffect is excute when splitvalues is empty.");
yield break;
}
// 当前伤害数值
int cur_damage_value = mDamageSplitValues[0];
mDamageSplitValues.RemoveAt(0);
// 当前特殊伤害效果数值
var curSpecsValues = mDamageSpecsSplitValues[0];;
mDamageSpecsSplitValues.RemoveAt(0);
var src_actor = src;
var target_actor = target;
if (target_actor != null && target_actor.transform != null)
{
if ((this.DamageEffectType & (uint)Damage.EDamageEffect.DE_NOHIT) != 0) // 闪避
{
if ((this.DamageEffectType & (uint)Damage.EDamageEffect.DE_ABSOLUTE_DOGE) != 0) // 绝对闪避
{
target_actor.ShowDamageEffect(FightEffectHelp.FightEffectType.AbsoluteDoge, SrcID);
}
else if ((this.DamageEffectType & (uint)Damage.EDamageEffect.DE_DODGE) != 0)// 闪避
{
target_actor.ShowDamageEffect(FightEffectHelp.FightEffectType.Dodge, SrcID);
}
else if ((this.DamageEffectType & (uint)Damage.EDamageEffect.DB_FIVE_ATTR) != 0)// 五行属性不足
{
if (src_actor.IsLocalPlayer)
{
ClientEventMgr.Instance.FireEvent((int)ClientEvent.CE_FIVE_ATTR_NOENOUGH, null);
}
}
}
else
{
// 攻击者进入战斗状态
if (src_actor != null)
{
src_actor.OnBattleTrigger();
}
// 伤害数字飘字
bool isCritic = (this.DamageEffectType & (uint)Damage.EDamageEffect.DE_CRITIC) != 0;
target_actor.DoDamage(SrcID, cur_damage_value, 0, isCritic, this.DamageEffectType);
// 受击效果飘字
if ((this.DamageEffectType == (uint)Damage.EDamageEffect.DE_BLOCK))//招架效果，需要显示伤害数字
{
BeattackedCtrl.ShowDamageEffect(this, (uint)Damage.EDamageEffect.DE_BLOCK, cur_damage_value);
}
else if ((this.DamageEffectType == (uint)Damage.EDamageEffect.DE_SUPER)) //无敌
{
BeattackedCtrl.ShowDamageEffect(this, (uint)Damage.EDamageEffect.DE_BLOCK, cur_damage_value);
}
// 附加伤害效果飘字
if (curSpecsValues != null)
{
foreach (var kv in curSpecsValues)
{
BeattackedCtrl.ShowDamageEffect(this, kv.Key, (int)kv.Value);
}
}
// 无敌类型不表现受击动作
if (this.DamageEffectType != (uint)Damage.EDamageEffect.DE_SUPER)
{
target_actor.Beattacked(this);
}
// 受击特效
if (!ShieldManager.Instance.IsHideBeattackEffect(src_actor, target_actor))
{
AnimationEffect.ResInitData effect_init_data = null;
if (skillInfo.BattleFxInfo != null)
{
effect_init_data = skillInfo.BattleFxInfo.BeattackEffectData;
}
else
{
effect_init_data = new AnimationEffect.ResInitData();
effect_init_data.BindNode = "root_node";
effect_init_data.FollowTarget = true;
effect_init_data.Effect = string.Format("{0}.prefab", GameConstHelper.GetString("GAME_COMMON_BEATTACK_EFFECT"));
effect_init_data.Audio = GameConstHelper.GetString("GAME_COMMON_BEATTACK_SOUND");
effect_init_data.EndTime = 3.0f;
}
target_actor.ShowDamageEffectModel(effect_init_data);
}
}
}
if (mDamageSplitValues.Count > 0)
{
float delay = 0.1f;
if (skillInfo.MultiHitDelayTimes != null)
{
delay = skillInfo.MultiHitDelayTimes[skillInfo.MultiHitRatios.Count - mDamageSplitValues.Count];
}
float attackspeed = 1.0f;
if (src_actor != null)
{
attackspeed = src_actor.AttackSpeed;
}
yield return(new SafeCoroutine.SafeWaitForSeconds(delay / attackspeed));
SafeCoroutine.CoroutineManager.StartCoroutine(HitEffectRoutine());
}
}
void TryAddSkillIds(List <uint> skillIds, DBDataAllSkill.AllSkillInfo allSkillInfo, DBSkillSev.SkillInfoSev skillInfo)
{
if (mkSelfActor == null || mkSelfActor.CDCtrl == null || mkSelfActor.AttackCtrl == null)
{
return;
}
if (allSkillInfo == null || skillInfo == null)
{
return;
}
if (mkSelfActor.CDCtrl.IsInCD(skillInfo.Id) == false && mkSelfActor.AttackCtrl.IsMpEnough(skillInfo.Id) == true)
{
// 怒气技能需要判断怒气是否足够
if (allSkillInfo.SetSlotType == DBDataAllSkill.SET_SLOT_TYPE.FurySkill)
{
if (LocalPlayerManager.Instance.Fury >= skillInfo.CostFury)
{
skillIds.Add(skillInfo.Id);
}
}
else if (allSkillInfo.SetSlotType == DBDataAllSkill.SET_SLOT_TYPE.MateSKill)
{
//不加入到自动
//nothing
}
else
{
skillIds.Add(skillInfo.Id);
}
}
}
/// <summary>
/// 响应受击消息
/// </summary>
/// <param name="beattackMsg"></param>
void HandleBeattacked(S2CNwarHit beattackMsg)
{
if (!mIsRecvMsg)
{
return;
}
DBSkillSev.SkillInfoSev skillInfo = DBSkillSev.Instance.GetSkillInfo(beattackMsg.hit.skill_id);
if (skillInfo == null)
{
GameDebug.LogError(string.Format("[HandleBeattacked]Skill ID:{0} info is null", beattackMsg.hit.skill_id));
return;
}
Damage dmg = new Damage();
uint src_id = beattackMsg.hit.act_id;
Actor actor = ActorManager.Instance.GetPlayer(beattackMsg.hit.act_id);
// 本地玩家受击，攻击者在角色列表中找不到的时候，需要给服务端发送look消息(目前AOI有bug)
if (actor == null && mOwner != null && mOwner.IsLocalPlayer)
{
mMissUID.obj_idx = beattackMsg.hit.act_id;
var cacheInfo = ActorManager.Instance.GetUnitCacheInfo(mMissUID);
if (cacheInfo == null)
{
var sendLookFix = new C2SNwarLookFix();
sendLookFix.uuid = beattackMsg.hit.act_id;
NetClient.GetCrossClient().SendData <C2SNwarLookFix>(NetMsg.MSG_NWAR_LOOK_FIX, sendLookFix);
}
}
if (beattackMsg.hit.ori_type == GameConst.SKILL_ORI_PET)
{
if (actor != null)
{
Player player = actor as Player;
if (player != null && player.CurrentPet != null)
{
src_id = player.CurrentPet.obj_idx;
}
}
}
dmg.SrcID = src_id;
dmg.TargetID = beattackMsg.hit.dst_id;
dmg.SkillID = beattackMsg.hit.skill_id;
dmg.BeattackState = Damage.EBeattackState.BS_BendBack;
dmg.DamageEffectType = beattackMsg.hit.hit_type;
dmg.DamageValue = (int)beattackMsg.hit.dmg;
dmg.DamageSpecs = new Dictionary <uint, int>(beattackMsg.hit.specs.Count);
foreach (var spec in beattackMsg.hit.specs)
{
dmg.DamageSpecs.Add(spec.k, (int)spec.v);
}
SkillAttackInstance inst = EffectManager.GetInstance().GetAttackInstance(beattackMsg.hit.em_id);
if (inst != null)
{
inst.AddHurtInfo(dmg);
}
else
{
dmg.HitEffect();
}
LastAttackerId = beattackMsg.hit.act_id;
}
