/// <summary>
/// 创建技能动作实体
/// </summary>
/// <param name="action"></param>
/// <returns></returns>
public static SkillActionEntity CreateSkillActionEntity(SkillAction action)
{
SkillActionEntity entity = new SkillActionEntity();
entity.action = action;
return(entity);
}
/// <summary>
/// 释放技能的时候移动
/// </summary>
/// <param name="action"></param>
private void AttackingMove(SkillAction action)
{
GameMotor motor = theOwner.motor;
if (motor == null)
{
return;
}
float extraSpeed = action.extraSpeed;
if (extraSpeed != 0)
{
motor.SetExtraSpeed(extraSpeed);
motor.SetMoveDirection(theOwner.Transform.forward);
//延迟extraSt时间后，设置速度为0
TimerHeap.AddTimer <GameMotor>((uint)action.extraSt, 0, (m) => { m.SetExtraSpeed(0); }, motor);
}
else
{
motor.SetExtraSpeed(0);
}
//如果该技能是带传送的，直接传送
if (action.teleportDistance > 0 && extraSpeed <= 0)
{
Vector3 dst = Vector3.zero;
dst = theOwner.Transform.position + theOwner.Transform.forward * action.teleportDistance;
motor.TeleportTo(dst);
}
}
/// <summary>
/// 发出攻击
/// </summary>
/// <param name="hitActionId"></param>
/// <param name="itwm"></param>
/// <param name="rotation"></param>
/// <param name="forward"></param>
/// <param name="position"></param>
public void OnAttacking(int hitActionId, Matrix4x4 ltwm, Quaternion rotation, Vector3 forward, Vector3 position)
{
SkillAction action = SkillAction.dataMap[hitActionId];
if (action.removeCollider == 1)
{
}
//动画动作
int act = action.action;
if (act > 0)
{
if (PlayerActionNames.animatorNames.ContainsKey(act))
{
theOwner.skillActName = PlayerActionNames.animatorNames[act];
}
else
{
Debug.LogWarning("找不到动作id");
theOwner.skillActName = "";
}
theOwner.SetAction(act);
}
AttackingFx(action);
AttackingMove(action);
AttackBuff(action);
List <object> args = new List <object>();
args.Add(ltwm);
args.Add(rotation);
args.Add(forward);
args.Add(position);
theOwner.delayAttackTimerID = TimerHeap.AddTimer((uint)(action.actionBeginDuration / theOwner.aiRate), 0, DelayAttack, hitActionId, args);
}
/// <summary>
/// 对指定技能添加动作实体
/// </summary>
/// <param name="id"></param>
/// <param name="action"></param>
public void AddSkillAction(int id, SkillAction action)
{
SkillEntity entity = GetSkill(id);
if (entity != null)
{
entity.AddAction(action);
}
}
public static List <int> CacuDamage(int hitActionID, uint attackerID, uint victimID)
{
List <int> result = new List <int>();
EntityParent attacker = null; //攻击者
EntityParent victimer = null; //受击者
double levelCorrect = 1.00f;
if (attackerID == GameWorld.thePlayer.ID && GameWorld.Entities.ContainsKey(victimID))
{
//如果攻击者刚好是主角，受击者刚好在场景中
attacker = GameWorld.thePlayer;
victimer = GameWorld.Entities[victimID] as EntityDummy;
double levelGap = victimer.Level - attacker.Level;
if (levelGap >= 20)
{
levelCorrect = 0.1f;
}
else if (levelGap > 10 && levelGap < 20)
{
levelCorrect = 1 - levelGap * 0.05f;
}
}
else if (victimID == GameWorld.thePlayer.ID && GameWorld.Entities.ContainsKey(attackerID))
{
//如果攻击者是客户端怪物，受击者是主角
attacker = GameWorld.Entities[attackerID];
victimer = GameWorld.thePlayer;
}
bool critFlag = false; //是否发生暴击
var atk = GetProperty(attacker, "Attack"); //角色的攻击力
double extraCritDamage = 0.00f; //暴击伤害
if (RandomHelper.GetRandomFloat() <= GetCritRate(attacker))
{
critFlag = true;
extraCritDamage = GetProperty(attacker, "critExtraAttack");
}
//1miss 2暴击 3普通攻击
int retFlag;
if (critFlag)
{
retFlag = 2;
}
else
{
retFlag = 3;
}
SkillAction skillData = SkillAction.dataMap[hitActionID];
int skillDamage = skillData.damage;
int addDamage = (int)CacuAddDamage(skillData, attacker, victimer);
result.Add(retFlag);
result.Add(skillDamage + addDamage);
return(result);
}
private void ProcessHit(EntityParent theOwner, int spellId, List <object> args)
{
int actionId = (int)args[0];
UnityEngine.Matrix4x4 ltwm = (UnityEngine.Matrix4x4)args[1];
UnityEngine.Quaternion rotation = (UnityEngine.Quaternion)args[2];
UnityEngine.Vector3 forward = (UnityEngine.Vector3)args[3];
UnityEngine.Vector3 position = (UnityEngine.Vector3)args[4];
if (theOwner is EntityDummy && theOwner.animator != null)
{
theOwner.animator.applyRootMotion = true;
}
SkillAction action = SkillAction.dataMap[actionId];
SkillData skill = SkillData.dataMap[spellId];
int duration = action.duration;
if (duration <= 0 && skill.skillAction.Count > 1)
{
if (SkillAction.dataMap[skill.skillAction[0]].duration <= 0)
{
//攻击结束，进入idle状态
theOwner.AddCallbackInFrames <int, EntityParent>((_actionId, _theOwner) =>
{
}, actionId, theOwner);
}
}
else if (duration > 0 && action.action > 0)
{
TimerHeap.AddTimer <int, EntityParent>((uint)duration, 0, (_actionID, _theOwner) =>
{
GameMotor theMotor = _theOwner.motor;
if (_theOwner.Transform)
{
theMotor.enableStick = true;
theMotor.SetExtraSpeed(0); //额外速度为0
theMotor.SetMoveDirection(Vector3.zero); //移动方向为（0，0，0）
}
_theOwner.ChangeMotionState(MotionState.IDLE); //改变状态为idle
}, actionId, theOwner);
}
//移除技能特效
if (action.duration > 0)
{
TimerHeap.AddTimer <int, EntityParent>((uint)action.duration, 0, (_actionID, _theOwner) =>
{
_theOwner.RemoveSfx(_actionID);
}, actionId, theOwner);
}
theOwner.OnAttacking(actionId, ltwm, rotation, forward, position);
}
/// <summary>
/// 显示攻击特效
/// </summary>
/// <param name="action"></param>
private void AttackingFx(SkillAction action)
{
if (!GameWorld.isShowSkillFx)
{
return;
}
theOwner.PlaySfx(action.id);
if (action.cameraTweenId > 0)
{
//如果有震屏，调用摄像机脚本的震屏API接口
}
if (string.IsNullOrEmpty(action.sound))
{
//技能释放音效
}
}
/// <summary>
/// 技能增加buff
/// </summary>
/// <param name="action"></param>
private void AttackBuff(SkillAction action)
{
if (action.casterAddBuff != null)
{
foreach (var id in action.casterAddBuff)
{
theOwner.ClientAddBuff(id);
}
}
if (action.casterDelBuff != null)
{
foreach (var id in action.casterDelBuff)
{
theOwner.ClientDelBuff(id);
}
}
}
public void AttackEffect(int hitActionID, Matrix4x4 ltwm, Quaternion rotation, Vector3 forward, Vector3 position)
{
SkillAction s = SkillAction.dataMap[hitActionID];
if (s.damageFlag == 0)//等于1才有伤害
{
return;
}
List <List <uint> > list = GetHitEntities(hitActionID, ltwm, rotation, forward, position);
if (list.Count != 4)
{
return;
}
if (theOwner is EntityMyself && list[0].Count > 0)
{
}
}
/// <summary>
/// 返回技能加成伤害
/// </summary>
/// <param name="skillData"></param>
/// <param name="attacker"></param>
/// <param name="victimer"></param>
/// <returns></returns>
public static double CacuAddDamage(SkillAction skillData, EntityParent attacker, EntityParent victimer)
{
if (skillData.damageAddType == (byte)damageAddType.AD)
{
var atk = GetProperty(attacker, "Attack");
return(skillData.damageAdd * atk);
}
else if (skillData.damageAddType == (byte)damageAddType.AP)
{
var ap = GetProperty(attacker, "AbilityPower");
return(skillData.damageAdd * ap);
}
else if (skillData.damageAddType == (byte)damageAddType.AR)
{
var ar = GetProperty(attacker, "Armor");
return(skillData.damageAdd * ar);
}
else if (skillData.damageAddType == (byte)damageAddType.MyselfHP)
{
var hp = GetProperty(attacker, "HP");
return(skillData.damageAdd * hp);
}
else if (skillData.damageAddType == (byte)damageAddType.OhterHP)
{
if (null == victimer)
{
var hp = GetProperty(attacker, "HP");
return(skillData.damageAdd * hp);
}
else
{
var hp = GetProperty(victimer, "HP");
return(skillData.damageAdd * hp);
}
}
return(0);
}
/// <summary>
/// 添加动作
/// </summary>
/// <param name="action"></param>
public void AddAction(SkillAction action)
{
actions.Add(action);
}
public void Process(EntityParent theOwner, params object[] args)
{
if (args.Length != 1)
{
Debug.LogError("没有攻击技能");
return;
}
int spellId = (int)args[0];
SkillData s = SkillData.dataMap[spellId];
theOwner.motor.speed = 0;
theOwner.motor.targetSpeed = 0;
int baseTime = 0;
for (int i = 0; i < s.skillAction.Count; i++)
{
SkillAction action = SkillAction.dataMap[s.skillAction[0]];
List <object> args1 = new List <object>();
args1.Add(s.skillAction[0]);
args1.Add(theOwner.Transform.localToWorldMatrix);
args1.Add(theOwner.Transform.rotation);
args1.Add(theOwner.Transform.forward);
args1.Add(theOwner.Transform.position);
//播放技能的第一个动作
if (i == 0)
{
ProcessHit(theOwner, spellId, args1);
if (theOwner is EntityMyself)
{
theOwner.motor.enableStick = action.enableStick > 0;
}
}
//如果没有后续动作了就跳出循环
if (i + 1 == s.skillAction.Count)
{
break;
}
//记录加到定时器里面的hit动作
uint tid = 0;
List <object> args2 = new List <object>();
args2.Add(s.skillAction[i + 1]);
args2.Add(theOwner.Transform.localToWorldMatrix);
args2.Add(theOwner.Transform.rotation);
args2.Add(theOwner.Transform.forward);
args2.Add(theOwner.Transform.position);
if (action.actionTime > 0)
{
tid = TimerHeap.AddTimer((uint)((baseTime + action.actionTime) / theOwner.aiRate), 0, ProcessHit, theOwner, spellId, args2);
baseTime += action.actionTime;
}
if (action.nextHitTime > 0)
{
tid = TimerHeap.AddTimer((uint)((baseTime + action.nextHitTime) / theOwner.aiRate), 0, ProcessHit, theOwner, spellId, args2);
baseTime += action.nextHitTime;
}
theOwner.hitTimer.Add(tid);
}
/*int actionID = (int)args[0];
* SkillActionData action = SkillActionData.dataMap[actionID];
* SkillData skill = SkillData.dataMap[theOwner.currSpellID];
* int duration = action.duration;
* if (duration <= 0 && skill.skillAction.Count > 1 && theOwner.hitActionIdx >= (skill.skillAction.Count - 1))
* {
* if (SkillActionData.dataMap[skill.skillAction[0]].duration <= 0)
* {
* //攻击结束，进入idle状态
* theOwner.AddCallbackInFrames<EntityParent>((_theOwner) =>
* {
*
* },theOwner);
* }
* }
* else if (duration > 0 && action.action > 0)
* {
* TimerHeap.AddTimer<int, EntityParent>((uint)duration, 0, (_actionID,_theOwner) =>
* {
* GameMotor theMotor = _theOwner.motor;
* if (_theOwner.Transform)
* {
* theMotor.enableStick = true;//驱动设置为静止
* theMotor.SetExtraSpeed(0);//额外速度为0
* theMotor.SetMoveDirection(Vector3.zero);//移动方向为（0，0，0）
* }
* _theOwner.ChangeMotionState(MotionState.IDLE);//改变状态为idle
* },actionID,theOwner);
* }
* if (action.duration > 0)
* {
* TimerHeap.AddTimer<int, EntityParent>((uint)action.duration, 0, (_actionID, _theOwner) =>
* {
*
* },actionID,theOwner);
* }*/
}