public void CreateActionEffect(int actionID, int skillID, Int64 entityUID, Transform heroTrans, Vector3 targetPos)
{
SkillActionData bData = SkillDataManager.Instance.GetSkillActionData(actionID);
if (bData == null)
{
////TraceUtil.Log("找不到动作特效配置信息");
return;
}
if (bData.m_effectPath == "0")
{
////TraceUtil.Log("未配置动作特效实体");
return;
}
Vector3 startPos = heroTrans.TransformPoint(bData.m_effect_start_pos.y, heroTrans.localPosition.y, bData.m_effect_start_pos.x); //配置表中的X对应3D中的Z，y对应3D中和X
float rotationY = heroTrans.eulerAngles.y + bData.m_effect_start_angel;
GameObject actionEffectPrefab = MapResManager.Instance.GetMapEffectPrefab(bData.m_effectPath);
GameObject actionEffect = GameObjectPool.Instance.AcquireLocal(actionEffectPrefab, startPos, Quaternion.Euler(0, rotationY, 0));
SkillEffectManager.Instance.AddEffect(new SkillEffectKey(entityUID, skillID), actionEffect);
ActionEffectBehaviour actionEffectBehaviour = actionEffect.GetComponent <ActionEffectBehaviour>();
if (actionEffectBehaviour == null)
{
actionEffectBehaviour = actionEffect.AddComponent <ActionEffectBehaviour>();
}
actionEffectBehaviour.InitDataConfig(bData, entityUID);
}
/// <summary>
/// 普通搜索
/// </summary>
/// <param name="context"></param>
/// <param name="data"></param>
/// <param name="param"></param>
private void NormalSearch(ISkillContext context,
SkillActionData data, CommonParam param)
{
NormalGetTargets(context, data, param);
FilterTarget(context, data, param);
}
public SkillActionData GetSkillActionData(int actionId)
{
SkillActionData data = null;
m_skillActionDataDictionary.TryGetValue(actionId, out data);
return(data);
}
/// <summary>
/// 弹射单次完成
/// </summary>
/// <param name="identifyId"></param>
public virtual void OnBounceNodeEnd(int identifyId, int activeId)
{
CommonParam param = GetParam(identifyId, false);
if (param == null)
{
return;
}
if (param.IsBounce) //弹射
{
SkillActionData bounceData = SkillUtil.GetSkillActionData(param.BounceParam.BounceActionId);
int maxBounceTime = int.Parse(bounceData.Para1); //最大允许的弹射次数
float.TryParse(bounceData.Para2, out float interval); //弹射间隔
if (param.BounceParam.BounceTime < maxBounceTime) //开始下一次弹射
{
object[] actionParam = { activeId, bounceData.Id, identifyId };
if (interval > 0)
{
var timerService = ServiceLocate.Instance.GetService <TimerService>();
timerService.CreateTimer(TryDoNextBounce, 0.1f, interval, actionParam);
}
else
{
TryDoNextBounce(true, actionParam);
}
}
else //超过弹射次数
{
SkillUtil.LogWarning("超过最大弹射次数 弹射取消 Max Time->" + maxBounceTime);
RemoveSkillAction(activeId, param);
}
}
}
private Vector3 GetCenterTarget(ISkillContext context,
SkillActionData data, CommonParam param)
{
var centerType = (SkillTargetCenter)data.Center;
Vector3 pos = Vector3.zero;
switch (centerType)
{
case SkillTargetCenter.Caster:
pos = context.GetSelfActor().GetTransform().position;
break;
case SkillTargetCenter.Target:
pos = param.ActorClicked?.GetTransform().position ?? pos;
break;
case SkillTargetCenter.Point:
pos = param.Postion;
break;
case SkillTargetCenter.Attacker:
//todo
break;
case SkillTargetCenter.Projectile:
//todo
break;
case SkillTargetCenter.ProjectileHitPoint:
//todo
break;
}
return(pos);
}
private bool Internal_TriggerAction(ISkill skill, int actionId, int identifyId, bool isBuff,
bool addSkillAction = true)
{
SkillActionData data = null;
if (!IsValid(skill, actionId, identifyId, isBuff, ref data))
{
return(false);
}
var param = skill.GetParam(identifyId, isBuff);
if (map.ContainsKey(data.ActionType))
{
// SkillUtil.Log(string.Format(" Trigger Type-> {0}", (SkillActionType) data.ActionType));
if (addSkillAction && !isBuff)
{
skill.AddSkillAction(actionId, identifyId);
}
map[data.ActionType].Action(skill, data, param);
}
else
{
SkillUtil.LogError(SkillUtil.GetSkillDebugDes(skill) + " Ation Type" + data.ActionType + " 未注册");
}
return(true);
}
public void Action(ISkill skill, SkillActionData data, CommonParam param)
{
if (SkillUtil.GetSkillActionDamage(skill.GetSkillLevel(), data, out int damage))
{
Damage(skill, param, damage);
}
skill.RemoveSkillAction(data.Id, param);
}
public void Action(ISkill skill, SkillActionData data, CommonParam param)
{
if (SkillUtil.TryParseWithDebug(data.Para1, out int removeBuffId, "remove BuffID"))
{
RemoveBuff(param, removeBuffId);
}
skill.RemoveSkillAction(data.Id, param);
}
public void Action(ISkill skill, SkillActionData data, CommonParam param)
{
if (SkillUtil.GetSkillActionHeal(skill.GetSkillLevel(), data, out int heal))
{
Heal(skill, param, heal);
}
skill.RemoveSkillAction(data.Id, param);
}
public void Setup(SkillActionData data)
{
m_actionData = data;
if (m_actionData != null)
{
//TODO:setup effect List
}
}
public void InitDataConfig(SkillActionData skillActionData, long entityID)
{
m_entityUid = entityID;
transform.RecursiveGetComponent <Animation>("Animation", out m_animations);
transform.RecursiveGetComponent <ParticleSystem>("ParticleSystem", out m_particleSystem);
//TraceUtil.Log("m_particleSystem:" + m_particleSystem.Count);
if (m_animations != null)
{
m_animations.ApplyAllItem(ani => ani.AnimComponent.Stop());
}
if (m_particleSystem != null)
{
m_particleSystem.ApplyAllItem(par => par.AnimComponent.Stop(true));
}
m_speed = skillActionData.m_effect_move_speed;
m_accleration = skillActionData.m_effect_move_accleration;
m_loopTimes = skillActionData.m_effect_loop_time;
if (m_animations != null)
{
m_animations.ApplyAllItem(animation =>
{
animation.LoopTimes = m_loopTimes;
animation.PlayTimeLength = animation.AnimComponent.clip.length;
animation.ComponentName = animation.AnimComponent.clip.name;
animation.PlayingTime = 0;
animation.PlayedTimes = 0;
var clipTimeLength = (m_loopTimes + 1) * animation.PlayTimeLength;
m_effectLifeTime = m_effectLifeTime >= clipTimeLength ? m_effectLifeTime : clipTimeLength;
});
}
if (m_particleSystem != null)
{
m_particleSystem.ApplyAllItem(particleSystem =>
{
particleSystem.LoopTimes = m_loopTimes;
particleSystem.PlayTimeLength = particleSystem.AnimComponent.duration;
particleSystem.ComponentName = particleSystem.ComponentName;
particleSystem.PlayingTime = 0;
particleSystem.PlayedTimes = 0;
var clipTimeLength = (m_loopTimes + 1) * particleSystem.PlayTimeLength;
m_effectLifeTime = m_effectLifeTime >= clipTimeLength ? m_effectLifeTime : clipTimeLength;
});
}
if (m_effectLifeTime == 0)
{
m_effectLifeTime = DEFAULT_EFFECT_LIFE_TIME;
}
Fire();
}
void ActionHandler(SkillActionData actData)
{
m_PlayerBehaviour.Invincible = (actData.m_invincible == 1);
m_PlayerBehaviour.IronBody = (actData.m_ironBody == 1);
m_actData = (SkillActionData)actData.Clone();
m_isAnimPlayed = false;
m_PlayerBehaviour.ChangeDisplayState(m_actData.m_moveType);
}
public void Action(ISkill skill, SkillActionData data, CommonParam param)
{
SkillUtil.TryParseWithDebug(data.Para1, out float delayTime, "Delay Time");
SkillUtil.TryParseWithDebug(data.Para1, out int actionId, "Action Id");
object[] actionParam = { skill, data, param, actionId };
var timer = ServiceLocate.Instance.GetService <TimerService>();
timer?.CreateTimer(DelayedCall, 0.1f, delayTime, actionParam);
}
public void GetTargets(ISkillContext context,
SkillActionData data, CommonParam param)
{
if (param.IsBounce && param.BounceParam.BounceTime > 1) //弹射
{
BounceSearch(context, data, param);
}
else
{
NormalSearch(context, data, param);
}
}
public void Action(ISkill skill, SkillActionData data, CommonParam param)
{
SkillUtil.TryParseWithDebug(data.Para1, out int probability, "概率");
SkillUtil.TryParseWithDebug(data.Para3, out int successActionId, "成功ActionId");
SkillUtil.TryParseWithDebug(data.Para3, out int failActionId, "失败ActionId");
float prob = probability / 100000.0f;
int actionId = SkillUtil.GetRandomValue() <= prob ? successActionId : failActionId;
SkillActionTrigger.Instance.Trigger(skill, actionId, param.IdentifyId);
skill.RemoveSkillAction(data.Id, param);
}
public void ActionHandler(SkillActionData actData)
{
m_PlayerBehaviour.Invincible = (actData.m_invincible == 1);
m_PlayerBehaviour.IronBody = (actData.m_ironBody == 1);
m_isAnimPlayed = false;
m_lockedTarget = null;
m_actData = (SkillActionData)actData.Clone();
((PlayerBehaviour)this.m_roleBehaviour).ChangeDisplayState(m_actData.m_moveType);
//2014-10-09 普通攻击的锁定目标计算规则有修改
//if (actData.m_ani_followtype == 1
// && m_PlayerBehaviour.ActionLockTarget!=null
// && m_PlayerBehaviour.ActionLockTarget.GO!=null
// && CheckAtAttackRange(m_PlayerBehaviour.ActionLockTarget))
if (actData.m_ani_followtype == 6 && //定速到达
m_PlayerBehaviour.ActionLockTarget != null &&
m_PlayerBehaviour.ActionLockTarget.GO != null)
{
m_lockedTarget = m_PlayerBehaviour.ActionLockTarget;
var targetPosition = m_PlayerBehaviour.ActionLockTarget.GO.transform.position;
m_PlayerBehaviour.ThisTransform.LookAt(new Vector3(targetPosition.x, m_PlayerBehaviour.ThisTransform.position.y, targetPosition.z));
}
else
{
m_PlayerBehaviour.ThisTransform.Rotate(0, m_actData.m_startAngle, 0);
}
m_attackDire = Quaternion.Euler(0, m_actData.m_angle, 0) * Vector3.forward;
//影子玩家参考主角方向
if (m_PlayerBehaviour.IsCopy)
{
m_attackDire = m_hero.transform.TransformDirection(m_attackDire);
}
else
{
m_attackDire = m_PlayerBehaviour.ThisTransform.TransformDirection(m_attackDire);
}
//判断Action的移动类型是否必达，如果是，则判断是为点还是可移动目标（目前只有点）。计算移动速度
if (m_skillBase.SkillData.m_directionParam == 2 && m_actData.m_ani_followtype == 3)
{
m_PlayerBehaviour.ChangeForward(m_touchPoint);
dis = Vector3.Distance(m_playerStartPosition, m_touchPoint);
s = dis / (m_actData.m_duration / 1000.0f);
s = s * Time.deltaTime;
}
//技能施放位置修正
Vector3 correctPos = new Vector3(m_actData.m_startPos.x, 0, m_actData.m_startPos.y);
correctPos = m_PlayerBehaviour.ThisTransform.TransformDirection(correctPos);
m_PlayerBehaviour.ThisTransform.Translate(correctPos);
this.IsStateReady = true;
}
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);
}
private bool IsValid(ISkill skill, int id, int identifyId, bool isBuff, ref SkillActionData data)
{
if (skill == null)
{
SkillUtil.LogError("skill is nullptr");
return(false);
}
data = SkillUtil.GetSkillActionData(id);
ISkillContext skillContext = skill.GetContext();
if (data == null)
{
SkillUtil.LogError(SkillUtil.GetSkillDebugDes(skill) + "技能数据尚未初始化");
return(false);
}
if (skillContext == null)
{
SkillUtil.LogError(SkillUtil.GetSkillDebugDes(skill) + "技能数据尚未初始化");
return(false);
}
var param = skill.GetParam(identifyId, isBuff);
if (param == null)
{
return(false);
}
SkillTargetSearch.Instance.GetTargets(skillContext, data, param);
if (!param.HasTargets())
{
if (param.IsBounce)
{
SkillUtil.Log(SkillUtil.GetSkillDebugDes(skill) + "技能没有目标 弹射结束");
skill.RemoveSkillAction(data.Id, param);
}
else
{
SkillUtil.LogError(SkillUtil.GetSkillDebugDes(skill) + "ActionID->" + id + " 技能没有目标");
}
return(false);
}
return(true);
}
private static bool GetSkillActionParamFromList(int lv, SkillActionData data, out int result)
{
result = 0;
if (data == null)
{
LogError("data is null");
return(false);
}
if (GetParamFromList(lv, data.Para1, out result))
{
return(true);
}
return(false);
}
public bool IsIgnoreBlock; //0=不需要无视阻挡，1=需要无视阻挡；
public object Clone()
{
SkillActionData skillActionData = (SkillActionData)this.MemberwiseClone();
if (this.m_effectGroup != null)
{
skillActionData.m_effectGroup = new int[this.m_effectGroup.Length];
for (int i = 0; i < this.m_effectGroup.Length; i++)
{
skillActionData.m_effectGroup[i] = this.m_effectGroup[i];
}
}
return(skillActionData);
}
private void FilterTarget(ISkillContext context, SkillActionData data, CommonParam param)
{
removelist.Clear();
var targets = param.Targets;
var needTeamType = (SkillTargetTeamType)data.Team;
for (int i = 0; i < targets.Count; i++)
{
var target = targets[i];
if (needTeamType != SkillTargetTeamType.ALl) //阵营
{
var targetTeamType = target.GetTargetTeamType();
if (target == context.GetSelfActor()) //todo 待数据层成型 删除
{
targetTeamType = SkillTargetTeamType.Friend;
}
if (targetTeamType != needTeamType)
{
removelist.Add(target);
}
}
if (!data.Type.Contains((int)SkillTargetType.All)) //类型
{
for (int j = 0; j < data.Type.Count; j++)
{
var needType = (SkillTargetType)data.Type[j];
if (needType == target.GetTargetType())
{
break;
}
if (j == data.Type.Count - 1)
{
removelist.Add(target);
}
}
}
}
for (int i = 0; i < removelist.Count; i++)
{
targets.Remove(removelist[i]);
}
}
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);
}
public Skill CreateSkill(uint skill_id, Actor owner)
{
SkillData skill_data = null;
if (!mClientSkillInfos.TryGetValue(skill_id, out skill_data))
{
var skill_info = DBSkillSev.Instance.GetSkillInfo(skill_id);
if (skill_info != null)
{
skill_data = SkillData.CreateSkillData(skill_info);
// 如果有子技能
if (skill_info.ParentSkillId != 0 && skill_info.ParentSkillId == skill_info.Id)
{
var cur_skill_data = skill_info;
while (cur_skill_data.ChildSkillId != 0)
{
var child_skill_info = DBSkillSev.Instance.GetSkillInfo(cur_skill_data.ChildSkillId);
if (child_skill_info == null)
{
break;
}
var child_action_data = SkillActionData.CreateSkillActionData(child_skill_info);
if (!skill_data.SkillActionList.Contains(child_action_data))
{
skill_data.SkillActionList.Add(child_action_data);
}
cur_skill_data = child_skill_info;
}
}
}
}
if (skill_data != null)
{
Skill skill = new Skill(skill_data);
skill.SetCaster(owner);
return(skill);
}
return(null);
}
public void ActionHandler(SkillActionData actData)
{
m_PlayerBehaviour.Invincible = (actData.m_invincible == 1);
m_PlayerBehaviour.IronBody = (actData.m_ironBody == 1);
m_actData = (SkillActionData)actData.Clone();
m_scrollDire = Quaternion.Euler(0, m_actData.m_angle, 0) * Vector3.forward;
//影子玩家参考主角方向
if (m_PlayerBehaviour.IsCopy)
{
m_scrollDire = m_hero.transform.TransformDirection(m_scrollDire);
}
else
{
m_scrollDire = m_PlayerBehaviour.ThisTransform.TransformDirection(m_scrollDire);
}
//TraceUtil.Log("开始滚动技能");
this.IsStateReady = true;
}
public void Action(ISkill skill, SkillActionData data, CommonParam param)
{
//拿到弹射特效的Action ID
var actionList = ConvertUtil.ConvertToIntList(data.Para3);
if (actionList == null || actionList.Count == 0)
{
return;
}
if (!param.IsBounce)
{
param.SetBounceState(true, data.Id, actionList[0]); //进入弹射状态
}
SkillActionTrigger.Instance.TriggerMultiple(skill, actionList, param.IdentifyId);
skill.RemoveSkillAction(data.Id, param);
}
public void ActionHandler(SkillActionData actData)
{
m_PlayerBehaviour.Invincible = (actData.m_invincible == 1);
m_PlayerBehaviour.IronBody = (actData.m_ironBody == 1);
m_isAnimPlayed = false;
m_lockedTarget = null;
marchForwardTargetPos = m_PlayerBehaviour.ThisTransform.position;
hitRadius = 0;
//Debug.Log("Action Start Time:" + Time.realtimeSinceStartup);
//2014-10-09 普通攻击的锁定目标计算规则有修改
//if (actData.m_ani_followtype == 1
// && m_PlayerBehaviour.ActionLockTarget!=null
// && m_PlayerBehaviour.ActionLockTarget.GO!=null
// && CheckAtAttackRange(m_PlayerBehaviour.ActionLockTarget))
if (actData.m_ani_followtype == 6 && //定速到达
m_PlayerBehaviour.ActionLockTarget != null &&
m_PlayerBehaviour.ActionLockTarget.GO != null)
{
m_lockedTarget = m_PlayerBehaviour.ActionLockTarget;
marchForwardTargetPos = new Vector3(m_lockedTarget.GO.transform.position.x, m_PlayerBehaviour.ThisTransform.position.y, m_lockedTarget.GO.transform.position.z);
m_PlayerBehaviour.ThisTransform.LookAt(marchForwardTargetPos);
//hitRadius = ((MonsterBehaviour)m_lockedTarget.Behaviour).m_MonsterConfigData._hitRadius;
hitRadius = CommonDefineManager.Instance.CommonDefine.ChargeOffset;
}
else
{
m_PlayerBehaviour.ThisTransform.Rotate(0, actData.m_startAngle, 0);
}
m_actData = (SkillActionData)actData.Clone();
m_attackDire = Quaternion.Euler(0, m_actData.m_angle, 0) * Vector3.forward;
//影子玩家参考主角方向
if (m_PlayerBehaviour.IsCopy)
{
m_attackDire = m_hero.transform.TransformDirection(m_attackDire);
}
else
{
m_attackDire = m_PlayerBehaviour.ThisTransform.TransformDirection(m_attackDire);
}
this.IsStateReady = true;
}
// 检测行为是否有效
// @actionData:行为数据
// return:有效返回true；否则false
private bool CheckActionIsValid(SkillActionData actionData)
{
if (!m_dicActNum.ContainsKey(actionData.i) || m_dicActNum[actionData.i] != 1)
{
return(false);
}
for (int i = 0; i < actionData.aH.Length; ++i)
{
int harmId = actionData.aH[i];
if (!CheckHurmIsValid(harmId))
{
return(false);
}
}
// 触发行为判断
if (actionData.tA == 0)
{
// 自己触发自己
for (int i = 0; i < actionData.aT.Length; ++i)
{
// 先判断触发id是否正确
SkillTriggerData tData = actionData.aT[i];
if (!m_dicActNum.ContainsKey(tData.i) || m_dicActNum[tData.i] != 1 || tData.i == actionData.i)
{
return(false);
}
for (int j = 0; j < m_skillData.aA.Length; ++j)
{
// 触发的行为不是触发行为
SkillActionData aData = m_skillData.aA[j];
if (aData.i == tData.i && aData.tA != 1)
{
return(false);
}
}
}
}
return(true);
}
// 绘制行为
private void DrawAction()
{
GUI.backgroundColor = Color.blue;
GUILayout.BeginVertical(new GUIStyle(EditorStyles.textField), GUILayout.Width(MENU_WIDTH), GUILayout.ExpandHeight(true), GUILayout.ExpandWidth(true));
GUI.backgroundColor = m_defaultBgClr;
// 标题
GUI.backgroundColor = Color.white;
GUILayout.BeginVertical();
GUILayout.Label("技能行为", m_styleTittle, GUILayout.Width(MENU_WIDTH), GUILayout.Height(40));
GUILayout.EndVertical(); // 标题
GUI.backgroundColor = m_defaultBgClr;
GUI.backgroundColor = Color.white;
GUILayout.BeginVertical(GUILayout.Height(630), GUILayout.ExpandHeight(true));
m_actionScroPos = GUILayout.BeginScrollView(m_actionScroPos, false, false);
for (int i = 0; i < m_skillData.aA.Length; ++i)
{
SkillActionData actionData = m_skillData.aA[i];
DrawActionItem(actionData);
}
GUILayout.FlexibleSpace();
GUILayout.EndScrollView();
GUILayout.EndVertical();
GUI.backgroundColor = m_defaultBgClr;
// +按钮
if (GUILayout.Button("+", GUILayout.Width(MENU_WIDTH), GUILayout.Height(40)))
{
List <SkillActionData> listAction = new List <SkillActionData>(m_skillData.aA);
SkillActionData actData = new SkillActionData();
actData.aH = new int[0];
actData.i = GetMaxActionDataId() + 1;
listAction.Add(actData);
m_skillData.aA = listAction.ToArray();
}
GUILayout.EndVertical(); // 绘制行为
}
public void CreateActionEffect(int actionID, int skillID, long entityUID)
{
//TraceUtil.Log("########actionID#" + actionID);
//TraceUtil.Log("#########skillID#" + skillID);
SkillActionData bData = SkillDataManager.Instance.GetSkillActionData(actionID);
if (bData == null)
{
return;
}
/*
* if (bData.m_effect_resource == null)
* {
* return;
* }
*
* Vector3 startPos = transform.TransformPoint(bData.m_effect_start_pos.y, transform.localPosition.y, bData.m_effect_start_pos.x); //配置表中的X对应3D中的Z，y对应3D中和X
* float rotationY = transform.eulerAngles.y + bData.m_effect_start_angel;
*
*
* m_curSkillEffect = GameObjectPool.Instance.AcquireLocal(bData.m_effect_resource, startPos, Quaternion.Euler(0, rotationY, 0));
*
*
* m_curSkillEffect.layer = 25;
* int num = m_curSkillEffect.transform.childCount;
* for (int i = 0; i < num; i++)
* {
* m_curSkillEffect.transform.GetChild(i).gameObject.layer = 25;
* }
*
* ActionEffectBehaviour actionEffectBehaviour = m_curSkillEffect.GetComponent<ActionEffectBehaviour>();
* if (actionEffectBehaviour == null)
* {
* actionEffectBehaviour = m_curSkillEffect.AddComponent<ActionEffectBehaviour>();
* }
* actionEffectBehaviour.InitDataConfig(bData, entityUID);
*/
}
public void ActionHandler(SkillActionData actData)
{
m_isAnimPlayed = false;
m_actData = (SkillActionData)actData.Clone();
ChangeDisplayState(m_actData.m_moveType);
if (animation.GetClip(m_actData.m_animationId) == null)
{
TraceUtil.Log("当前角色不包含" + m_actData.m_animationId + "动画名称");
return;
}
var t = Time.deltaTime;
var s = m_actData.m_startSpeed * t + m_actData.m_acceleration * Mathf.Pow(t, 2) * 0.5f;
m_actData.m_startSpeed += Mathf.FloorToInt(m_actData.m_acceleration * t);
if (!m_isAnimPlayed || animation[m_actData.m_animationId].wrapMode == WrapMode.Loop)
{
animation.Play(m_actData.m_animationId);
m_isAnimPlayed = true;
}
}
