787 lines
32 KiB
C#
787 lines
32 KiB
C#
using Thousandto.Code.Logic;
|
|
using Thousandto.Code.Logic.WarningField;
|
|
using Thousandto.Core.Asset;
|
|
using Thousandto.Core.Base;
|
|
using Thousandto.SkillEditor;
|
|
using Thousandto.SkillEditor.DIY;
|
|
using Thousandto.SkillEditor.Support;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Text.RegularExpressions;
|
|
using UnityEditor;
|
|
using UnityEngine;
|
|
using Thousandto.Cfg.Data;
|
|
using Thousandto.Launcher.ExternalLibs;
|
|
|
|
namespace Thousandto.SkillEditor.DIY
|
|
{
|
|
public enum EditorEntityState
|
|
{
|
|
Idle,
|
|
Move,
|
|
Jump,
|
|
|
|
HitStiff, //受击僵直
|
|
HitBack, //击退
|
|
HitFly, //击飞
|
|
Lie, //击飞后倒地
|
|
HitGrab, //抓取
|
|
}
|
|
|
|
public class EditorEntity : EditorBaseObject
|
|
{
|
|
#region//私有变量
|
|
private AnimationPlayer _animPlayer = null;
|
|
private EditorEntityState _curState = EditorEntityState.Idle;
|
|
private Vector3 _moveDir = Vector3.forward;
|
|
private ForwardRoter _roter = null;
|
|
private float _scale = 1f;
|
|
private float _moveSpeed = 6f;
|
|
|
|
private Vector3 _jumpStart = Vector3.zero;
|
|
private Vector3 _jumpCenter = Vector3.zero;
|
|
private Vector3 _jumpTarget = Vector3.zero;
|
|
private float _jumpTimer = 0f;
|
|
private const float JumpTime = 1f;
|
|
|
|
|
|
private float _hitStateTimer = 0f;
|
|
private HitEffectInfo _hitEffectInfo = null;
|
|
|
|
private Vector3 _hitBackOriPos = Vector3.zero;
|
|
private Vector3 _hitBackTargetPos = Vector3.zero;
|
|
|
|
private float _getUpAnimTime = 0f;
|
|
private float _lieTime = 0f;
|
|
private Vector3[] _hitFlyCurve = null;
|
|
|
|
private Vector3 _grabOriPos = Vector3.zero;
|
|
private Vector3 _grabTargetPos = Vector3.zero;
|
|
|
|
private Material _mater = null;
|
|
private float _blinkTimer = 0f;
|
|
private float _blinkMaxTime = 0f;
|
|
private float _blinkPower = 0f;
|
|
private Color _blinkColor = Color.white;
|
|
private AnimationCurve _blinkCurve = null;
|
|
|
|
private AnimationPlayer _animPlayerRun = null;
|
|
private GameObject _runGo = null;
|
|
private bool _hideWeapon = false;
|
|
private List<GameObject> _weaponList = new List<GameObject>();
|
|
#endregion
|
|
|
|
#region//属性
|
|
public EditorEntityState CurState { get { return _curState; } }
|
|
public bool DisableMove { get; set; }
|
|
public bool DisableChangeDir { get; set; }
|
|
public EditorSkillManager SkillManager { get; private set; }
|
|
public bool IsPauseAnim { get; private set; }
|
|
public bool HideWeapon
|
|
{
|
|
get
|
|
{
|
|
return _hideWeapon;
|
|
}
|
|
set
|
|
{
|
|
if (_hideWeapon != value)
|
|
{
|
|
_hideWeapon = value;
|
|
for (int i = 0; i < _weaponList.Count; ++i)
|
|
{
|
|
_weaponList[i].SetActive(!_hideWeapon);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
public ForwardRoter Roter { get { return _roter; } }
|
|
#endregion
|
|
|
|
#region//构造函数
|
|
public EditorEntity(GameObject rootGo, EditorObjType objType, float scale, float moveSpeed) :
|
|
base(rootGo, objType)
|
|
{
|
|
var anim = UnityUtils.RequireComponent<AnimListBaseScript>(rootGo);
|
|
anim.AddClips(AnimInfo.GetClips(anim.AnimAssetPathDic.Values));
|
|
_animPlayer = new AnimationPlayer(anim);
|
|
_roter = new ForwardRoter();
|
|
_roter.CurForward = RootGo.transform.forward;
|
|
_roter.CurSpeed = 0.7f;
|
|
SkillManager = new EditorSkillManager(this);
|
|
|
|
var render = RootTrans.GetComponentInChildren<SkinnedMeshRenderer>();
|
|
_mater = render.material;
|
|
|
|
_runGo = (GameObject)GameObject.Instantiate(rootGo);
|
|
anim = UnityUtils.RequireComponent<AnimListBaseScript>(_runGo);
|
|
anim.AddClips(AnimInfo.GetClips(anim.AnimAssetPathDic.Values));
|
|
_animPlayerRun = new AnimationPlayer(anim);
|
|
_runGo.SetActive(false);
|
|
_runGo.transform.parent = _runGo.transform;
|
|
_scale = scale;
|
|
_moveSpeed = moveSpeed;
|
|
if(_moveSpeed < 1f)
|
|
{
|
|
_moveSpeed = 1f;
|
|
}
|
|
|
|
StopSate();
|
|
}
|
|
#endregion
|
|
|
|
#region//
|
|
public void StopSate()
|
|
{
|
|
if (_curState == EditorEntityState.Jump)
|
|
return;
|
|
|
|
if (_curState != EditorEntityState.Idle || !_animPlayer.IsPlaying)
|
|
{
|
|
if (IsPauseAnim)
|
|
{
|
|
_animPlayer.Stop();
|
|
IsPauseAnim = false;
|
|
_runGo.SetActive(false);
|
|
}
|
|
|
|
if(_animPlayer.UseHalfBody)
|
|
{
|
|
if (_animPlayer.UPPart.IsPlaying && FPlayerAnimRelation.GetLogicType(_animPlayer.UPPart.CurState.ParentAnimName) == FAnimLogicType.Skill &&
|
|
_animPlayer.LowerPart.IsPlaying && FPlayerAnimRelation.GetLogicType(_animPlayer.LowerPart.CurState.ParentAnimName) == FAnimLogicType.Skill)
|
|
{
|
|
//上下半身都是播放技能动作，不替换动作
|
|
}
|
|
else if (_animPlayer.UPPart.IsPlaying && FPlayerAnimRelation.GetLogicType(_animPlayer.UPPart.CurState.ParentAnimName) == FAnimLogicType.Skill)
|
|
{
|
|
//如果只有上半身在播放技能动作
|
|
if (_animPlayer.UPPart.CurState.ClipLength * (1f - _animPlayer.UPPart.CurState.CurNormalizeTime) < 0.2f)
|
|
{
|
|
//如果上半身的时间已经不够融合了直接播放idle
|
|
_animPlayer.Play(ObjType == EditorObjType.Player ? AnimClipNameDefine.FightIdle : AnimClipNameDefine.NormalIdle, AnimationPartType.AllBody, WrapMode.Loop);
|
|
}
|
|
else
|
|
{
|
|
//如果上半身在放技能动作，播放整体技能动作
|
|
string animName = FPlayerAnimRelation.SkillMoveToIdle(_animPlayer.UPPart.CurState.ParentAnimName);
|
|
_animPlayer.Play(animName, AnimationPartType.AllBody,
|
|
_animPlayer.UPPart.CurState.WrapMode,
|
|
true, 0.2f,
|
|
_animPlayer.UPPart.CurState.Speed,
|
|
_animPlayer.UPPart.CurState.CurNormalizeTime);
|
|
}
|
|
}
|
|
else if (!SkillManager.IsUsing)
|
|
{
|
|
_animPlayer.Play(ObjType == EditorObjType.Player ? AnimClipNameDefine.FightIdle : AnimClipNameDefine.NormalIdle, AnimationPartType.AllBody, WrapMode.Loop);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (!SkillManager.IsUsing)
|
|
{
|
|
_animPlayer.Play(AnimClipNameDefine.NormalIdle, AnimationPartType.AllBody, WrapMode.Loop);
|
|
}
|
|
}
|
|
}
|
|
_curState = EditorEntityState.Idle;
|
|
}
|
|
|
|
float VectorAngle(Vector2 from, Vector2 to)
|
|
{
|
|
float angle;
|
|
|
|
Vector3 cross = Vector3.Cross(from, to);
|
|
angle = Vector2.Angle(from, to);
|
|
return cross.z > 0 ? -angle : angle;
|
|
}
|
|
|
|
public void MoveTo(Vector3 dir, EditorEntity target)
|
|
{
|
|
if (_curState == EditorEntityState.Jump)
|
|
return;
|
|
if (IsPauseAnim)
|
|
{
|
|
_animPlayer.Stop();
|
|
IsPauseAnim = false;
|
|
_runGo.SetActive(false);
|
|
}
|
|
_moveDir = dir;
|
|
_moveDir.y = 0f;
|
|
_moveDir = _moveDir.normalized;
|
|
if (DisableMove)
|
|
{
|
|
if (!DisableChangeDir)
|
|
{
|
|
_roter.DestForward = _moveDir;
|
|
}
|
|
return;
|
|
}
|
|
|
|
var modelDir = _moveDir;
|
|
var animName = AnimClipNameDefine.FightRunFront;
|
|
if (target != null && Vector3.SqrMagnitude(target.RootTrans.position - RootTrans.position) < 100f)
|
|
{
|
|
var tarDir = target.RootTrans.position - RootTrans.position;
|
|
tarDir.y = 0f;
|
|
tarDir = tarDir.normalized;
|
|
var angle = VectorAngle(new Vector2(_moveDir.x, _moveDir.z), new Vector2(tarDir.x, tarDir.z));
|
|
|
|
//4方向
|
|
if ((angle >= 0 && angle <= 45f) || (angle <= 0 && angle >= -45f))
|
|
{
|
|
modelDir = _moveDir;
|
|
animName = AnimClipNameDefine.FightRunFront;
|
|
}
|
|
else if (angle >= 135f || angle <= -135)
|
|
{
|
|
modelDir = -_moveDir;
|
|
animName = AnimClipNameDefine.FightRunBack;
|
|
}
|
|
else if (angle >= 0f)
|
|
{
|
|
modelDir = tarDir;
|
|
animName = AnimClipNameDefine.FightRunLeft;
|
|
}
|
|
else if (angle < 0f)
|
|
{
|
|
modelDir = tarDir;
|
|
animName = AnimClipNameDefine.FightRunRight;
|
|
}
|
|
}
|
|
if (_curState != EditorEntityState.Move || !_animPlayer.IsPlaying || (_animPlayer.UseHalfBody && !_animPlayer.IsLowerPlayAnim(animName)))
|
|
{
|
|
if(_animPlayer.UseHalfBody)
|
|
{
|
|
float normalTime = 0f;
|
|
if (_animPlayer.LowerPart.IsPlaying && FPlayerAnimRelation.GetLogicType(_animPlayer.LowerPart.CurState.ParentAnimName) == FAnimLogicType.Move)
|
|
{
|
|
normalTime = _animPlayer.LowerPart.CurState.CurNormalizeTime;
|
|
}
|
|
|
|
if (_animPlayer.UPPart.IsPlaying && FPlayerAnimRelation.GetLogicType(_animPlayer.UPPart.CurState.ParentAnimName) == FAnimLogicType.Skill
|
|
&& _animPlayer.LowerPart.IsPlaying && FPlayerAnimRelation.GetLogicType(_animPlayer.LowerPart.CurState.ParentAnimName) == FAnimLogicType.Skill)
|
|
{
|
|
//如果上下半身都在播放技能，尝试切换到移动技能动作
|
|
string moveSkill = FPlayerAnimRelation.SkillIdleToMove(_animPlayer.UPPart.CurState.ParentAnimName);
|
|
if (_animPlayer.Play(moveSkill, AnimationPartType.UpBody,
|
|
_animPlayer.UPPart.CurState.WrapMode, true, 0.2f,
|
|
_animPlayer.UPPart.CurState.Speed,
|
|
_animPlayer.UPPart.CurState.CurNormalizeTime))
|
|
{
|
|
//如果可以切换到移动技能动作，下半身播放移动动作
|
|
if (!_animPlayer.LowerPart.IsPlaying || _animPlayer.LowerPart.CurState.ParentAnimName != animName)
|
|
{
|
|
_animPlayer.Play(animName, AnimationPartType.LowerBody, WrapMode.Loop, true, 0.2f, 1f, normalTime);
|
|
}
|
|
}
|
|
else if (!SkillManager.IsUsing)
|
|
{
|
|
//如果正在播放技能收招动作，直接切换
|
|
_animPlayer.Play(animName, AnimationPartType.AllBody, WrapMode.Loop, true, 0.2f, 1f, normalTime);
|
|
}
|
|
}
|
|
else if (_animPlayer.UPPart.IsPlaying && FPlayerAnimRelation.GetLogicType(_animPlayer.UPPart.CurState.ParentAnimName) == FAnimLogicType.Skill)
|
|
{
|
|
//上半身在播放技能，下半身播放跑步动作
|
|
if (!_animPlayer.LowerPart.IsPlaying || _animPlayer.LowerPart.CurState.ParentAnimName != animName)
|
|
{
|
|
_animPlayer.Play(animName, AnimationPartType.LowerBody, WrapMode.Loop, true, 0.2f, 1f, normalTime);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (!SkillManager.IsUsing)
|
|
{
|
|
_animPlayer.Play(animName, AnimationPartType.AllBody, WrapMode.Loop, true, 0.2f, 1f, normalTime);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (!SkillManager.IsUsing)
|
|
{
|
|
_animPlayer.Play(AnimClipNameDefine.NormalRun, AnimationPartType.AllBody, WrapMode.Loop, true, 0.2f, 1f, 0f);
|
|
}
|
|
}
|
|
}
|
|
_roter.DestForward = modelDir;
|
|
_curState = EditorEntityState.Move;
|
|
}
|
|
|
|
public void JumpTo(Vector3 dir)
|
|
{
|
|
if (_curState == EditorEntityState.Jump)
|
|
return;
|
|
if (DisableMove)
|
|
return;
|
|
if (IsPauseAnim)
|
|
{
|
|
_animPlayer.Stop();
|
|
IsPauseAnim = false;
|
|
_runGo.SetActive(false);
|
|
}
|
|
dir.y = 0f;
|
|
dir = dir.normalized;
|
|
_jumpStart = RootTrans.position;
|
|
_jumpTimer = 0f;
|
|
if (dir == Vector3.zero)
|
|
{
|
|
//原地跳跃
|
|
_jumpTarget = RootTrans.position;
|
|
_jumpCenter = RootTrans.position + Vector3.up * 5f;
|
|
}
|
|
else
|
|
{
|
|
//方向跳跃
|
|
_jumpTarget = dir * 6f + _jumpStart;
|
|
_jumpCenter = Vector3.Lerp(_jumpTarget, _jumpStart, 0.5f);
|
|
_jumpCenter += Vector3.up * 5f;
|
|
}
|
|
_animPlayer.Play("jump", AnimationPartType.AllBody, WrapMode.Once, true, 0.2f, 0.5f / JumpTime);
|
|
_roter.DestForward = _moveDir;
|
|
_curState = EditorEntityState.Jump;
|
|
}
|
|
|
|
public void DoHitEffect(EditorBaseObject user, Vector3 mainDir, HitEffectInfo hitInfo)
|
|
{
|
|
Vector3 dir = Vector3.zero;
|
|
if (hitInfo.HitDirType == SkillHitDirType.RealDir)
|
|
{
|
|
dir = RootTrans.position - user.RootTrans.position;
|
|
}
|
|
else
|
|
{
|
|
dir = mainDir;
|
|
}
|
|
dir.y = 0;
|
|
dir = dir.normalized;
|
|
DoHitEffect(user.RootTrans.position, dir, hitInfo);
|
|
}
|
|
|
|
public void DoHitEffect(EditorLockFlyVfx flyVfx, HitEffectInfo hitInfo)
|
|
{
|
|
var dir = RootTrans.position - flyVfx.RootTrans.position;
|
|
dir.y = 0;
|
|
dir = dir.normalized;
|
|
DoHitEffect(flyVfx.RootTrans.position, dir, hitInfo);
|
|
}
|
|
|
|
public SkillHitType HitTypeCheck(HitEffectInfo hitInfo)
|
|
{
|
|
switch (hitInfo.HitType)
|
|
{
|
|
case SkillHitType.HitStiff:
|
|
case SkillHitType.HitBack:
|
|
if (CurState == EditorEntityState.HitFly)
|
|
{
|
|
//追击击飞
|
|
return SkillHitType.HitFly;
|
|
}
|
|
break;
|
|
}
|
|
return hitInfo.HitType;
|
|
}
|
|
|
|
public void DoHitEffect(Vector3 userPos, Vector3 dir, HitEffectInfo hitInfo)
|
|
{
|
|
if (IsPauseAnim)
|
|
{
|
|
_animPlayer.Stop();
|
|
IsPauseAnim = false;
|
|
_runGo.SetActive(false);
|
|
}
|
|
_hitEffectInfo = hitInfo;
|
|
//播放受击特效
|
|
if(hitInfo.HitVfx > 0)
|
|
{
|
|
var hitTrans = SlotUtils.GetSlotTransform(RootTrans, hitInfo.HitSlot);
|
|
var resPath = AssetUtils.GetModelAssetPath(ModelTypeCode.SkillVFX, hitInfo.HitVfx);
|
|
EditorVFXPlayer.Instance.PlayVFX(resPath, hitTrans);
|
|
}
|
|
|
|
//播放闪烁效果
|
|
Blink(hitInfo.BlinkTime, hitInfo.BlinkPower, hitInfo.BlinkColor, hitInfo.BlinkCurve);
|
|
//播放受击效果
|
|
var hitType = HitTypeCheck(hitInfo);
|
|
switch (hitType)
|
|
{
|
|
case SkillHitType.None:
|
|
{
|
|
_roter.DestForward = -dir;
|
|
PlayAnim(hitInfo.HitAnim, WrapMode.Once, 1f, 0f);
|
|
}
|
|
break;
|
|
case SkillHitType.HitStiff:
|
|
{
|
|
_roter.DestForward = -dir;
|
|
PlayAnim(hitInfo.HitAnim, WrapMode.Once, 1f, 0f);
|
|
_curState = EditorEntityState.HitStiff;
|
|
_hitStateTimer = 0f;
|
|
}
|
|
break;
|
|
case SkillHitType.HitBack:
|
|
{
|
|
_roter.DestForward = -dir;
|
|
PlayAnim(hitInfo.HitAnim, WrapMode.Once, 1f, 0f);
|
|
_curState = EditorEntityState.HitBack;
|
|
_hitStateTimer = 0f;
|
|
_hitBackOriPos = RootTrans.position;
|
|
_hitBackTargetPos = RootTrans.position + hitInfo.BackDis * dir;
|
|
_hitBackTargetPos.y = 0f;
|
|
}
|
|
break;
|
|
case SkillHitType.HitFly:
|
|
{
|
|
_roter.DestForward = -dir;
|
|
var flyPoint = new Vector3[3];
|
|
var targetPos = RootTrans.position + dir * hitInfo.FlyDis;
|
|
targetPos.y = 0f;
|
|
PlayAnim(AnimClipNameDefine.HitFly, WrapMode.Once, 0.45f / _hitEffectInfo.FlyTime, 0f);
|
|
|
|
List<Vector3> path = new List<Vector3>(hitInfo.HitFlyHeightCurve.keys.Length);
|
|
float curveTime = hitInfo.HitFlyHeightCurve.keys[hitInfo.HitFlyHeightCurve.keys.Length - 1].time;
|
|
for (int i = 0; i < hitInfo.HitFlyHeightCurve.keys.Length; ++i)
|
|
{
|
|
var key = hitInfo.HitFlyHeightCurve.keys[i];
|
|
var lerpValue = key.time / curveTime;
|
|
var pos = Vector3.Lerp(RootTrans.position, targetPos, lerpValue);
|
|
pos.y += key.value;
|
|
path.Add(pos);
|
|
}
|
|
_hitFlyCurve = iTween.PathControlPointGenerator(path.ToArray());
|
|
_hitStateTimer = 0f;
|
|
|
|
_lieTime = hitInfo.LieTime;
|
|
_getUpAnimTime = _animPlayer.GetClipLength(AnimClipNameDefine.GetUp);
|
|
_curState = EditorEntityState.HitFly;
|
|
}
|
|
break;
|
|
case SkillHitType.HitGrab:
|
|
{
|
|
_hitStateTimer = 0f;
|
|
_grabOriPos = RootTrans.position;
|
|
var vtargetPos = userPos + dir * hitInfo.GrabPos;
|
|
vtargetPos.y = 0f;
|
|
var grabDir = _grabOriPos - vtargetPos;
|
|
grabDir.y = 0f;
|
|
grabDir = grabDir.normalized;
|
|
if (Vector3.Distance(_grabOriPos, vtargetPos) > hitInfo.GrabDis)
|
|
{
|
|
_grabTargetPos = vtargetPos + grabDir * hitInfo.GrabPos;
|
|
}
|
|
else
|
|
{
|
|
_grabTargetPos = vtargetPos;
|
|
}
|
|
_animPlayer.Play(_hitEffectInfo.HitAnim, AnimationPartType.AllBody, WrapMode.Once);
|
|
_curState = EditorEntityState.HitGrab;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
public void Blink(float time, float power, Color color, AnimationCurve curve)
|
|
{
|
|
_blinkTimer = 0f;
|
|
_blinkMaxTime = time;
|
|
_blinkPower = power;
|
|
_blinkColor = color;
|
|
_blinkCurve = curve;
|
|
|
|
_mater.shader = Shader.Find("Ares/EntityState/BeHit");
|
|
_mater.SetColor("_RimColor", _blinkColor);
|
|
_mater.SetFloat("_RimPower", (1f - _blinkCurve.Evaluate(0f)) * _blinkPower);
|
|
}
|
|
public void PlayAnim(string animName, WrapMode wrapMode, float speed, float normalizedTime)
|
|
{
|
|
if (IsPauseAnim)
|
|
{
|
|
_animPlayer.Stop();
|
|
IsPauseAnim = false;
|
|
_runGo.SetActive(false);
|
|
}
|
|
if (CurState != EditorEntityState.Idle)
|
|
{
|
|
var curLogicType = FPlayerAnimRelation.GetLogicType(animName);
|
|
if (curLogicType == FAnimLogicType.Skill)
|
|
{
|
|
var runSkillName = FPlayerAnimRelation.SkillIdleToMove(animName);
|
|
if (_animPlayer.Play(runSkillName, AnimationPartType.UpBody, wrapMode, true, 0.2f, speed, normalizedTime))
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
_animPlayer.Play(animName, AnimationPartType.AllBody, wrapMode, true, 0.2f, speed, normalizedTime);
|
|
}
|
|
public void StopAnim()
|
|
{
|
|
_animPlayer.Stop();
|
|
}
|
|
|
|
public void Update(float dt)
|
|
{
|
|
_roter.Update(dt);
|
|
RootTrans.forward = _roter.CurForward;
|
|
_animPlayer.Update(dt);
|
|
SkillManager.Update(dt);
|
|
|
|
if (_blinkMaxTime > 0f && _blinkTimer < _blinkMaxTime)
|
|
{
|
|
_blinkTimer += dt;
|
|
if (_blinkTimer >= _blinkMaxTime)
|
|
{
|
|
//结束闪烁
|
|
_blinkMaxTime = -1f;
|
|
_mater.shader = Shader.Find("Ares/Entity/Monster");
|
|
_mater.SetColor("_Color", Color.white);
|
|
_mater.SetFloat("_ColorMultiplier", 1f);
|
|
}
|
|
else
|
|
{
|
|
_mater.SetFloat("_RimPower", (1f - _blinkCurve.Evaluate(_blinkTimer / _blinkMaxTime)) * _blinkPower);
|
|
}
|
|
}
|
|
|
|
switch (_curState)
|
|
{
|
|
case EditorEntityState.Idle:
|
|
{
|
|
if (!_animPlayer.IsPlaying && !SkillManager.IsUsing)
|
|
{
|
|
_animPlayer.Play(ObjType == EditorObjType.Player ? AnimClipNameDefine.FightIdle : AnimClipNameDefine.NormalIdle, AnimationPartType.AllBody, WrapMode.Loop);
|
|
}
|
|
}
|
|
break;
|
|
case EditorEntityState.Move:
|
|
{
|
|
if (!_animPlayer.IsPlaying)
|
|
{
|
|
//_animPlayer.Play(AnimClipNameDefine.FightRunFront, true, WrapMode.Loop);
|
|
}
|
|
RootTrans.position += _moveDir * dt * _moveSpeed;
|
|
if (DisableMove)
|
|
{
|
|
StopSate();
|
|
}
|
|
}
|
|
break;
|
|
case EditorEntityState.Jump:
|
|
{
|
|
_jumpTimer += dt;
|
|
if (_jumpTimer <= JumpTime)
|
|
{
|
|
float lerpValue = _jumpTimer / JumpTime;
|
|
RootTrans.position = (1 - lerpValue) * (1 - lerpValue) * _jumpStart + 2 * lerpValue * (1 - lerpValue) * _jumpCenter + lerpValue * lerpValue * _jumpTarget;
|
|
}
|
|
else
|
|
{
|
|
RootTrans.position = _jumpTarget;
|
|
_curState = EditorEntityState.Idle;
|
|
StopSate();
|
|
}
|
|
}
|
|
break;
|
|
case EditorEntityState.HitStiff:
|
|
{
|
|
_hitStateTimer += dt;
|
|
if (_hitStateTimer >= _hitEffectInfo.HitEffectTime)
|
|
{
|
|
StopSate();
|
|
}
|
|
}
|
|
break;
|
|
case EditorEntityState.HitBack:
|
|
{
|
|
_hitStateTimer += dt;
|
|
if (_hitStateTimer >= _hitEffectInfo.HitEffectTime)
|
|
{
|
|
StopSate();
|
|
RootTrans.position = _hitBackTargetPos;
|
|
}
|
|
else
|
|
{
|
|
var lerpValue = _hitEffectInfo.HitTimeCurve.Evaluate(_hitStateTimer / _hitEffectInfo.HitEffectTime);
|
|
RootTrans.position = Vector3.Lerp(_hitBackOriPos, _hitBackTargetPos, lerpValue);
|
|
}
|
|
}
|
|
break;
|
|
case EditorEntityState.HitFly:
|
|
{
|
|
_hitStateTimer += dt;
|
|
if (_hitStateTimer >= _hitEffectInfo.FlyTime)
|
|
{
|
|
_animPlayer.Play(AnimClipNameDefine.Lie, AnimationPartType.AllBody, WrapMode.Loop);
|
|
RootTrans.position = iTween.Interp(_hitFlyCurve, 1f);
|
|
_curState = EditorEntityState.Lie;
|
|
_hitStateTimer = 0f;
|
|
}
|
|
else
|
|
{
|
|
var lerpValue = _hitStateTimer / _hitEffectInfo.FlyTime * _hitEffectInfo.HitTimeCurve.keys[_hitEffectInfo.HitTimeCurve.keys.Length - 1].time;
|
|
lerpValue = Mathf.Clamp01(_hitEffectInfo.HitTimeCurve.Evaluate(lerpValue));
|
|
RootTrans.position = iTween.Interp(_hitFlyCurve, lerpValue);
|
|
}
|
|
}
|
|
break;
|
|
case EditorEntityState.Lie:
|
|
{
|
|
if (_lieTime > _getUpAnimTime)
|
|
{
|
|
float value = _lieTime - _getUpAnimTime;
|
|
if (_hitStateTimer <= value)
|
|
{
|
|
_hitStateTimer += dt;
|
|
if (_hitStateTimer > value)
|
|
{
|
|
_animPlayer.Play(AnimClipNameDefine.GetUp, AnimationPartType.AllBody, WrapMode.Once);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
_hitStateTimer += dt;
|
|
if (_hitStateTimer > _lieTime)
|
|
{
|
|
StopSate();
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
_hitStateTimer += dt;
|
|
if (_hitStateTimer > _lieTime)
|
|
{
|
|
StopSate();
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case EditorEntityState.HitGrab:
|
|
{
|
|
_hitStateTimer += dt;
|
|
if (_hitStateTimer <= _hitEffectInfo.HitEffectTime)
|
|
{
|
|
var lerpValue = _hitStateTimer / _hitEffectInfo.HitEffectTime;
|
|
RootTrans.position = Vector3.Lerp(_grabOriPos, _grabTargetPos, _hitEffectInfo.HitTimeCurve.Evaluate(lerpValue));
|
|
}
|
|
else
|
|
{
|
|
RootTrans.position = _grabTargetPos;
|
|
StopSate();
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
public void UseSkill(SkillVisualInfo skill)
|
|
{
|
|
SkillManager.UseSkill(skill);
|
|
}
|
|
|
|
public void StopAllSkill()
|
|
{
|
|
SkillManager.StopAllSkill();
|
|
}
|
|
|
|
public void DoPauseAnim(SkillVisualInfo skill, int frame, bool showPauseContrast)
|
|
{
|
|
if (SkillManager.IsUsing)
|
|
return;
|
|
if (CurState != EditorEntityState.Idle)
|
|
return;
|
|
|
|
String animName = String.Empty;
|
|
int playFrame = 0;
|
|
float startNor = 0f;
|
|
bool isLoop = false;
|
|
for (int i = skill.DataList.Count - 1; i >= 0; --i)
|
|
{
|
|
var eventInfo = skill.DataList[i];
|
|
if (eventInfo.IsEnable && eventInfo.EventType == SkillEventDefine.PlayAnimation && eventInfo.EventFrame <= frame)
|
|
{
|
|
var animEvent = eventInfo as PlayAnimEventInfo;
|
|
animName = animEvent.AnimName;
|
|
playFrame = frame - eventInfo.EventFrame;
|
|
startNor = animEvent.NormalizedTime;
|
|
isLoop = animEvent.Loop != 0;
|
|
break;
|
|
}
|
|
}
|
|
var animTime = _animPlayer.GetClipLength(animName);
|
|
if (animTime > 0f)
|
|
{
|
|
var normalizedTime = (playFrame * EditorSkill.OneFrameTime) / animTime;
|
|
_animPlayer.Play(animName, AnimationPartType.AllBody, WrapMode.Once, false, 0f, 0f, normalizedTime);
|
|
IsPauseAnim = true;
|
|
|
|
if (showPauseContrast)
|
|
{
|
|
_runGo.SetActive(true);
|
|
_runGo.transform.position = RootTrans.position;
|
|
_runGo.transform.forward = RootTrans.forward;
|
|
|
|
var runAnimName = FPlayerAnimRelation.SkillIdleToMove(animName);
|
|
if (!string.IsNullOrEmpty(runAnimName))
|
|
{
|
|
_animPlayerRun.Play(runAnimName, AnimationPartType.UpBody, WrapMode.Once, false, 0f, 0f, normalizedTime);
|
|
_animPlayerRun.Play(AnimClipNameDefine.FightRunFront, AnimationPartType.LowerBody, WrapMode.Once, false, 0f, 0f, normalizedTime);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
_runGo.SetActive(false);
|
|
}
|
|
}
|
|
}
|
|
|
|
public bool LoadWeapon(int modelID)
|
|
{
|
|
var resPath = AssetUtils.GetModelAssetPath(ModelTypeCode.GodWeapon, modelID);
|
|
GameObject prefab = ResourcesEx.Load(resPath, typeof(GameObject)) as GameObject;
|
|
if (prefab == null)
|
|
return false;
|
|
|
|
for (int i = 0; i < _weaponList.Count; ++i)
|
|
{
|
|
GameObject.DestroyImmediate(_weaponList[i], true);
|
|
}
|
|
_weaponList.Clear();
|
|
|
|
GameObject model = (GameObject)GameObject.Instantiate(prefab);
|
|
var leftModel = model.transform.Find("left");
|
|
var rightModel = model.transform.Find("right");
|
|
if (leftModel != null && rightModel != null)
|
|
{
|
|
//双手武器
|
|
_weaponList.Add(leftModel.gameObject);
|
|
_weaponList.Add(rightModel.gameObject);
|
|
_weaponList.Add(model);
|
|
|
|
var slotL = SlotUtils.GetSlotTransform(RootTrans, Slot.LeftWeapon);
|
|
leftModel.parent = slotL;
|
|
UnityUtils.Reset(leftModel);
|
|
|
|
var slotR = SlotUtils.GetSlotTransform(RootTrans, Slot.RightWeapon);
|
|
rightModel.parent = slotR;
|
|
UnityUtils.Reset(rightModel);
|
|
|
|
model.transform.parent = RootTrans;
|
|
}
|
|
else
|
|
{
|
|
//单手武器
|
|
_weaponList.Add(model);
|
|
|
|
var slotR = SlotUtils.GetSlotTransform(RootTrans, Slot.RightWeapon);
|
|
model.transform.parent = slotR;
|
|
UnityUtils.Reset(model.transform);
|
|
}
|
|
return true;
|
|
}
|
|
#endregion
|
|
}
|
|
}
|