// Update is called once per frame
void Update()
{
if (IsActive)
{
if (Time.time < m_LastTriggerTime + m_AnimationPlayer.AnimationLenth(m_StartAnim))
{
}
else if (Time.time < m_LastTriggerTime + m_AnimationPlayer.AnimationLenth(m_StartAnim) + m_MovingTime)
{
if (!m_AnimationPlayer.IsPlaying(m_RotateAnim))
{
m_AnimationPlayer.Play(m_RotateAnim);
}
if (!m_HasRotateEffect)
{
m_HasRotateEffect = true;
if (null != m_RotateEffect)
{
GameObject rotateEffect = ResourceSystem.NewObject(m_RotateEffect, m_MovingTime) as GameObject;
if (null != rotateEffect)
{
Transform parent = LogicSystem.FindChildRecursive(this.transform, m_RotateEffectBone);
if (null != parent)
{
rotateEffect.transform.parent = parent;
rotateEffect.transform.localPosition = Vector3.zero;
rotateEffect.transform.localRotation = Quaternion.identity;
m_EffectList.Add(rotateEffect);
}
}
}
}
Vector3 motion = m_Direction * Time.deltaTime * m_Speed;
if (!m_MoveController.isGrounded)
{
motion.y += -9.8f * Time.deltaTime;
}
m_MoveController.Move(m_Direction * Time.deltaTime * m_Speed);
LogicSystem.NotifyGfxUpdatePosition(gameObject, this.transform.position.x, this.transform.position.y, this.transform.position.z, 0, this.transform.rotation.eulerAngles.y * Mathf.PI / 180f, 0);
HandleDamage();
}
else if (Time.time < m_LastTriggerTime + m_AnimationPlayer.AnimationLenth(m_StartAnim) + m_MovingTime + m_AnimationPlayer.AnimationLenth(m_EndAnim))
{
if (!m_AnimationPlayer.IsPlaying(m_EndAnim))
{
SetEndure(gameObject, false);
m_AnimationPlayer.Play(m_EndAnim);
}
}
else
{
StopSkill();
}
if (IsLogicDead())
{
NotifyNpcDead(gameObject);
StopSkill();
}
}
}
private void ApplyGravity(GameObject target, float delta, SkillAnimInfo animInfo)
{
if (target == null)
{
return;
}
if (!Script_Util.IsOnGround(target, GroundTweak))
{
StartControlGravity();
m_Vertical += Gravity * delta;
Vector3 posOff = m_Vertical * delta;
Vector3 pos = target.transform.position + posOff;
Component controller = target.GetComponent <CharacterController>();
if (controller != null)
{
((CharacterController)controller).Move(posOff);
}
else
{
target.transform.position += posOff;
}
LogicSystem.NotifyGfxUpdatePosition(target, pos.x, pos.y, pos.z);
}
else
{
EndControlGravity();
}
}
public override bool Execute(object sender, SkillInstance instance, long delta, long curSectionTime)
{
GameObject obj = sender as GameObject;
if (null != obj)
{
if (curSectionTime <= m_Duration)
{
float dist = (float)(int)delta / 1000.0f * m_Velocity;
UnityEngine.Vector3 targetPos = obj.transform.position + obj.transform.forward * dist;
CharacterController ctrl = obj.GetComponent <CharacterController>() as CharacterController;
if (null != ctrl)
{
ctrl.Move(obj.transform.forward * dist);
}
else
{
obj.transform.position = targetPos;
}
LogicSystem.NotifyGfxUpdatePosition(obj, targetPos.x, targetPos.y, targetPos.z);
return(true);
}
else
{
return(true);
}
}
else
{
return(false);
}
}
public override bool Execute(object sender, SkillInstance instance, long delta, long curSectionTime)
{
if (curSectionTime < m_StartTime)
{
return(true);
}
UnityEngine.GameObject obj = sender as UnityEngine.GameObject;
if (obj == null)
{
return(false);
}
SharedGameObjectInfo owner_info = LogicSystem.GetSharedGameObjectInfo(obj);
if (owner_info.Summons.Count <= 0)
{
return(false);
}
UnityEngine.GameObject first_summon = LogicSystem.GetGameObject(owner_info.Summons[0]);
if (first_summon == null)
{
return(false);
}
UnityEngine.Vector3 summon_pos = first_summon.transform.position;
first_summon.transform.position = obj.transform.position;
obj.transform.position = summon_pos;
LogicSystem.NotifyGfxUpdatePosition(obj, obj.transform.position.x, obj.transform.position.y, obj.transform.position.z);
LogicSystem.NotifyGfxUpdatePosition(first_summon, first_summon.transform.position.x,
first_summon.transform.position.y, first_summon.transform.position.z);
return(false);
}
public static void ChangeDir(GameObject obj, float direction)
{
UnityEngine.Vector3 rotate = new UnityEngine.Vector3(0, direction * 180 / UnityEngine.Mathf.PI, 0);
obj.transform.eulerAngles = rotate;
LogicSystem.NotifyGfxUpdatePosition(obj, obj.transform.position.x, obj.transform.position.y,
obj.transform.position.z, 0, direction, 0);
}
protected override void UpdateMovement(ImpactLogicInfo info, float deltaTime)
{
///////////// temp code,禁止某些受击带来的位置突变
bool bNoMovement = false;
if (info.ConfigData.ParamNum == 4 && info.ConfigData.ExtraParams[3] == "456")
{
bNoMovement = true;
}
if (!bNoMovement)
{
if (null != info.ConfigData && null != info.Target)
{
float speedRate = GetLockFrameRate(info, Time.time - info.StartTime);
UnityEngine.Vector3 motion = info.MoveDir * info.MovementInfo.GetSpeedByTime(info.ElapsedTimeForEffect) * deltaTime * speedRate;
info.NormalPos += motion;
motion = GfxImpactSystem.Instance.GetAdjustPoint(info.NormalPos - info.OrignalPos, info) + info.OrignalPos - info.Target.transform.position;
UnityEngine.Vector3 pos = info.Target.transform.position + motion;
pos = new UnityEngine.Vector3(pos.x, GetTerrainHeight(pos), pos.z);
MoveTo(info.Target, pos);
LogicSystem.NotifyGfxUpdatePosition(info.Target, info.Target.transform.position.x, info.Target.transform.position.y, info.Target.transform.position.z, 0, info.Target.transform.rotation.eulerAngles.y * UnityEngine.Mathf.PI / 180f, 0);
}
}
}
private void ProcessAttractImpact(GameObject attacker, List <GameObject> targets, Vector3 pos, float attractOff, float disMin)
{
if (targets == null || targets.Count <= 0)
{
return;
}
foreach (GameObject target in targets)
{
if (target != null)
{
Vector3 attractDir = pos - target.transform.position;
float distance = attractDir.magnitude;
if (distance >= disMin)
{
Vector3 posOff = attractDir.normalized * attractOff;
Vector3 targetPos = target.transform.position + posOff;
Component controller = target.GetComponent <CharacterController>();
if (controller != null)
{
((CharacterController)controller).Move(posOff);
}
else
{
target.transform.position += posOff;
}
LogicSystem.NotifyGfxUpdatePosition(target, targetPos.x, targetPos.y, targetPos.z);
TriggerImpl.RecordTarget(GetAttacker(), target);
}
}
}
}
public virtual void UpdateSkill()
{
if (m_ObjAnimation == null)
{
return;
}
if (m_IsSkillActive)
{
Vector3 pos = gameObject.transform.position;
LogicSystem.NotifyGfxUpdatePosition(gameObject, pos.x, pos.y, pos.z);
if (CheckSkillOver())
{
m_IsSkillActive = false;
StopSkill();
}
}
if (m_IsHaveCollideMoveCurve)
{
if (!string.IsNullOrEmpty(m_CollideMoveCurve) && m_ColliderManager.IsCollided())
{
m_SkillMovement.StartCurveMove(m_CollideMoveCurve);
m_IsHaveCollideMoveCurve = false;
}
}
}
public static void UpdateObjPosition(GameObject obj)
{
if (obj == null)
{
return;
}
LogicSystem.NotifyGfxUpdatePosition(obj, obj.transform.position.x, obj.transform.position.y, obj.transform.position.z);
}
public static void ChangeDir(GameObject obj, UnityEngine.Vector3 dir)
{
dir.y = 0;
obj.transform.forward = dir;
UnityEngine.Vector3 rotate = obj.transform.rotation.eulerAngles;
LogicSystem.NotifyGfxUpdatePosition(obj, obj.transform.position.x, obj.transform.position.y,
obj.transform.position.z, 0, rotate.y * UnityEngine.Mathf.PI / 180, 0);
}
public static void UpdateObjTransform(GameObject obj)
{
if (obj == null)
{
return;
}
LogicSystem.NotifyGfxUpdatePosition(obj, obj.transform.position.x, obj.transform.position.y, obj.transform.position.z,
0, (float)(obj.transform.rotation.eulerAngles.y * Math.PI / 180.0f), 0);
}
// Update is called once per frame
void Update()
{
if (IsActive)
{
if (null != m_Player)
{
if (Vector3.Distance(this.transform.position, m_Player.transform.position) < m_SafeDis + 1.0f)
{
Quaternion rotation = Quaternion.LookRotation(GetFleeDir());
if (m_MinAngle < Mathf.Abs(Quaternion.Angle(this.transform.rotation, rotation)))
{
this.transform.rotation = Quaternion.Lerp(this.transform.rotation, rotation, 0.2f);
}
else
{
if (!m_AnimationPlayer.IsPlaying(m_FleeAnim.name))
{
m_AnimationPlayer.Play(m_FleeAnim.name);
}
if (m_MoveController.isGrounded)
{
m_YSpeed = 0.0f;
}
else
{
m_YSpeed += Time.deltaTime * m_Gravity;
}
m_MoveController.Move((this.transform.forward * m_FleeSpeed + new Vector3(0, m_YSpeed, 0)) * Time.deltaTime);
}
}
else if (Vector3.Distance(this.transform.position, m_Player.transform.position) > m_SafeDis)
{
Quaternion faceRotation = Quaternion.LookRotation(GetFleeDir() * -1);
if (m_MinAngle < Mathf.Abs(Quaternion.Angle(this.transform.rotation, faceRotation)))
{
this.transform.rotation = Quaternion.Lerp(this.transform.rotation, faceRotation, 0.2f);
}
else
{
StopSkill();
}
}
LogicSystem.NotifyGfxUpdatePosition(gameObject, this.transform.position.x, this.transform.position.y, this.transform.position.z, 0, this.transform.rotation.eulerAngles.y * Mathf.PI / 180.0f, 0);
}
else
{
StopSkill();
}
if (Time.time > m_LastTriggerTime + m_MaxFleeTime)
{
StopSkill();
}
}
}
public void SetFacePos(Vector3 targetPos)
{
Vector3 dir = targetPos - transform.position;
dir.y = 0;
transform.forward = dir;
Vector3 rotate = gameObject.transform.rotation.eulerAngles;
LogicSystem.NotifyGfxUpdatePosition(gameObject, transform.position.x, transform.position.y,
transform.position.z, 0, rotate.y * Mathf.PI / 180, 0);
}
protected void GeneralTickImpact(float delatTime)
{
TickEffect(delatTime);
TickAnimation(delatTime);
TickMovement(delatTime);
if (m_IsHitHighLight && Time.time > m_StartTime + m_HitHilghtLightTime)
{
m_IsHitHighLight = false;
m_Renderer.material = m_NormalMaterial;
}
LogicSystem.NotifyGfxUpdatePosition(gameObject, this.transform.position.x, this.transform.position.y, this.transform.position.z, 0, this.transform.rotation.eulerAngles.y * Mathf.PI / 180f, 0);
}
protected override void UpdateMovement(ImpactLogicInfo info, float deltaTime)
{
if (null != info.ConfigData && null != info.Target)
{
info.Velocity = info.MoveDir * info.MovementInfo.GetSpeedByTime(Time.time - info.StartTime);
UnityEngine.Vector3 motion = info.Velocity * deltaTime;
info.NormalPos += motion;
motion = GfxImpactSystem.Instance.GetAdjustPoint(info.NormalPos - info.OrignalPos, info) + info.OrignalPos - info.Target.transform.position;
UnityEngine.Vector3 pos = info.Target.transform.position + motion;
pos = new UnityEngine.Vector3(pos.x, GetTerrainHeight(pos), pos.z);
MoveTo(info.Target, pos);
LogicSystem.NotifyGfxUpdatePosition(info.Target, info.Target.transform.position.x, info.Target.transform.position.y, info.Target.transform.position.z, 0, info.Target.transform.rotation.eulerAngles.y * UnityEngine.Mathf.PI / 180f, 0);
}
}
public void SetFacePos(Vector3 targetPos, MathRange YRotateRange)
{
//Debug.Log("---face: cur pos " + gameObject.transform.position + " target-pos:" + targetPos);
Vector3 dir = targetPos - transform.position;
//dir.y = 0;
transform.forward = dir;
Vector3 rotate = gameObject.transform.rotation.eulerAngles;
rotate.x = YRotateRange.Clip(rotate.x);
gameObject.transform.rotation = Quaternion.Euler(rotate);
LogicSystem.NotifyGfxUpdatePosition(gameObject, transform.position.x, transform.position.y, transform.position.z,
0, rotate.y * Mathf.PI / 180, 0);
}
// Update is called once per frame
void Update()
{
if (IsActive)
{
if (Time.time < m_LastTriggerTime + m_AnimationPlayer.AnimationLenth(m_StartAnim.name))
{
}
else if (Time.time < m_LastTriggerTime + m_AnimationPlayer.AnimationLenth(m_StartAnim.name) + m_AnimationPlayer.AnimationLenth(m_BladeAnim.name))
{
if (!m_AnimationPlayer.IsPlaying(m_BladeAnim.name))
{
m_AnimationPlayer.Play(m_BladeAnim.name);
}
m_MoveController.Move(Time.deltaTime * m_MoveSpeed * this.transform.forward);
LogicSystem.NotifyGfxUpdatePosition(gameObject, this.transform.position.x, this.transform.position.y, this.transform.position.z, 0, this.transform.rotation.eulerAngles.y * Mathf.PI / 180f, 0);
}
else if (Time.time < m_LastTriggerTime + m_AnimationPlayer.AnimationLenth(m_StartAnim.name) + m_AnimationPlayer.AnimationLenth(m_BladeAnim.name) + m_AnimationPlayer.AnimationLenth(m_EndAnim.name))
{
if (!m_AnimationPlayer.IsPlaying(m_EndAnim.name))
{
m_AnimationPlayer.CrossFade(m_EndAnim.name);
}
}
else
{
StopSkill();
}
if (Time.time > m_LastTriggerTime + m_DamageDelay && !m_HasDamageSend)
{
m_HasDamageSend = true;
if (m_DamageAngle <= 0.1 || m_DamageRange <= 0.1)
{
return;
}
foreach (GameObject obj in GetObjInSector(this.transform.position - this.transform.forward * 0.0f, m_DamageRange, m_DamageAngle))
{
if (obj.tag == "Player")
{
ImpactInfo impact = m_ImpactInfo.Clone() as ImpactInfo;
impact.Attacker = gameObject;
impact.m_Velocity = this.transform.forward * impact.m_Velocity.z;
ImpactSystem.Instance.SendImpact(gameObject, obj, impact as ImpactInfo);
}
}
}
}
}
protected override void UpdateMovement(ImpactLogicInfo info, float deltaTime)
{
// update virtical
if (null != info.ConfigData && null != info.Target)
{
HitFlyParams param = GetHitFlyParams(info);
float virticalSpeed = info.Velocity.y;
info.Velocity = info.MoveDir * info.MovementInfo.GetSpeedByTime(Time.time - info.StartTime, -30);
UnityEngine.Vector3 motion = UnityEngine.Vector3.zero;
if (HitFlyState.Rising == param.ImpactState || HitFlyState.Falling == param.ImpactState)
{
info.Velocity = new UnityEngine.Vector3(info.Velocity.x, info.Velocity.y, info.Velocity.z);
}
else
{
info.Velocity = new UnityEngine.Vector3(info.Velocity.x, 0.0f, info.Velocity.z);
}
motion = info.Velocity * deltaTime;
info.NormalPos += motion;
motion = GfxImpactSystem.Instance.GetAdjustPoint(info.NormalPos - info.OrignalPos, info) + info.OrignalPos - info.Target.transform.position;
Move(info.Target, motion);
LogicSystem.NotifyGfxUpdatePosition(info.Target, info.Target.transform.position.x, info.Target.transform.position.y, info.Target.transform.position.z, 0, info.Target.transform.rotation.eulerAngles.y * UnityEngine.Mathf.PI / 180f, 0);
}
}
private void OnMovePos(Vector3 posTarget, Vector3 posOff)
{
LogicSystem.NotifyGfxUpdatePosition(this.gameObject, posTarget.x, posTarget.y, posTarget.z);
}
