public override bool StartSkill(Vector3 targetPos)
{
ResetSkill();
CDBeginTime = Time.time;
Vector3 curTargetPos;
if (UseCurTargetPos)
{
if (TriggerImpl.GetCurTargetPos(this.gameObject, out curTargetPos))
{
targetPos = curTargetPos;
}
else
{
return(StopSkill());
}
}
if (UseFaceTargetPos || targetPos == Vector3.zero)
{
TargetPos = Script_Util.GetRoleFaceTargetPos(this.gameObject);
}
else
{
TargetPos = targetPos;
AdjustTargetPos();
}
TriggerImpl.ResetTarget(this.gameObject);
SkillComponent.ChangeSection((int)SkillSection.ShootStart);
return(true);
}
/// param:Id[对应到SkillSceneObjManager中的SoundEffect Id], pos[场景绝对位置]
/// example:2,0 2 3
public void Trigger_PlaySoundAtPosBySoundId(string param)
{
#if SHOOTER_LOG
Debug.Log("Trigger_PlaySoundAtPosBySoundId param:" + param);
#endif
SkillSceneObjInfo sobjInfo = new SkillSceneObjInfo(param);
Vector3 targetPos = Vector3.zero;
try {
if (sobjInfo.paramOther.Count > 0)
{
targetPos = Script_Util.ToVector3(sobjInfo.paramOther[0]);
}
else
{
Debug.Log("Trigger_PlaySoundAtPosBySoundId miss pos");
return;
}
} catch (System.Exception ex) {
Debug.Log("Trigger_PlaySoundAtPosBySoundId pos convert error");
return;
}
if (m_SceneObjMgr != null)
{
SkillSoundInfo soundInfo = m_SceneObjMgr.TryGetSkillSoundInfo(sobjInfo.Id);
if (soundInfo != null)
{
TriggerImpl.PlaySoundAtPos(soundInfo, targetPos);
}
}
else
{
Debug.Log("Trigger_PlaySoundAtPosBySoundId null");
}
}
private void DropWeapon(WeaponHand type)
{
if (m_Weapons.ContainsKey(type))
{
GameObject weapon = m_Weapons[type];
Script_Util.DetachGameObject(weapon);
GameObject.DestroyObject(weapon);
m_Weapons.Remove(type);
}
// Make Sure Remove All Children
Transform t = LogicSystem.FindChildRecursive(this.gameObject.transform, GetBoneName(type));
if (t != null)
{
int childCount = t.childCount;
for (int index = 0; index < childCount; index++)
{
Transform child = t.GetChild(index);
child.parent = null;
GameObject.Destroy(child.gameObject);
}
t.DetachChildren();
}
}
private List <GameObject> FindTarget(Vector3 pos, float range, int mask)
{
List <GameObject> targetInfos = new List <GameObject>();
Collider[] hitColliders = Physics.OverlapSphere(pos, range, mask);
int index = 0;
while (index < hitColliders.Length)
{
if (hitColliders[index] == null || hitColliders[index].gameObject == null)
{
index++;
continue;
}
GameObject target = hitColliders[index].gameObject;
if (target != null)
{
if (Script_Util.IsChildGameObject(GetAttacker(), target.GetInstanceID()))
{
index++;
continue;
}
targetInfos.Add(target);
}
index++;
}
return(targetInfos);
}
private void ExecuteMoveInternal(float delta, Vector3 gravity)
{
m_Velocity += delta * gravity;
Vector3 tVelocity = m_Target.transform.rotation * m_Velocity;
Vector3 posOff = tVelocity * delta;
Vector3 pos = m_Target.transform.position + posOff;
Component controller = m_Target.GetComponent <CharacterController>();
if (controller != null)
{
((CharacterController)controller).Move(posOff);
}
else
{
m_Target.transform.position += posOff;
}
if (m_OnMovePos != null)
{
m_OnMovePos(pos, posOff);
}
float disWithGround = Script_Util.GetHeightWithGround(m_Target.transform);
if (disWithGround <= 0 && m_OnHitGround != null)
{
m_OnHitGround(m_Target.transform.position, disWithGround);
}
}
private void StartMove()
{
m_MoveDuration = 0;
m_MoveElapsed = 0;
m_IsMoving = true;
Vector3 rayDirRevert = m_BulletInfo.MoveDir * (-1);
Vector3 impactScrPos = m_BulletInfo.ImpactSrcPos + rayDirRevert * m_BulletInfo.MoveImpactRadius;
Ray ray = new Ray(impactScrPos, m_BulletInfo.MoveDir);
RaycastHit[] targetHitInfos = Physics.SphereCastAll(ray, m_BulletInfo.MoveImpactRadius,
m_BulletInfo.MoveDistanceMax);
Script_Util.DrawPhysicsSphereCastLine(ray, m_BulletInfo.MoveDistanceMax, m_BulletInfo.MoveImpactRadius, Color.red, 10.0f);
if (targetHitInfos != null && targetHitInfos.Length > 0)
{
Script_Util.SortRaycastHit(ref targetHitInfos);
m_IsHit = true;
m_MoveHitInfo = targetHitInfos[0];
m_MoveDuration = m_MoveHitInfo.distance / m_BulletInfo.MoveSpeed;
m_HitPos = m_MoveHitInfo.point;
}
else
{
m_IsHit = false;
m_MoveDuration = m_BulletInfo.MoveDistanceMax / m_BulletInfo.MoveSpeed;
m_HitPos = Script_Util.CaculateRelativePos(m_BulletInfo.MoveStartPos,
m_BulletInfo.MoveDir, m_BulletInfo.MoveDistanceMax);
}
}
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 NumericMovementInfo(string param)
{
string[] result = Script_Util.SplitParam(param, 2);
if (result != null)
{
Speed = Convert.ToSingle(result[0]);
Accelerate = Convert.ToSingle(result[1]);
}
}
public SkillAnimProcedureInfo(string param)
{
string[] result = Script_Util.SplitParam(param, 3);
if (result != null)
{
Duration = Convert.ToSingle(result[0]);
BoneName = result[1];
AnimName = result[2];
}
}
public Vector3 ExtractVector3(int index)
{
string ret = ExtractString(index);
if (!string.IsNullOrEmpty(ret))
{
return(Script_Util.ToVector3(ret));
}
return(Vector3.zero);
}
public static void ProcessVerticalImpact(GameObject attacker, GameObject sender,
SkillImpactInfos impacts, float verticalHeight = 10.0f, float verticalHeightStart = 0.0f,
float SectorDegree = 360.0f, int hitCount = 1)
{
bool isTargeted = false;
// Find Targets
Ray ray = new Ray(
sender.transform.position + new Vector3(0, verticalHeightStart - impacts.ImpactRadius, 0),
Vector3.up);
RaycastHit[] targetHitInfos = Physics.SphereCastAll(ray, impacts.ImpactRadius,
verticalHeight, (int)SceneLayerType.Character);
Script_Util.DrawPhysicsSphereCastLine(ray, verticalHeight, impacts.ImpactRadius, Color.red, 10.0f);
int index = 0;
while (index < targetHitInfos.Length)
{
if (targetHitInfos[index].collider == null || targetHitInfos[index].collider.gameObject == null)
{
index++;
continue;
}
GameObject target = targetHitInfos[index].collider.gameObject;
if (target != null)
{
Vector3 targetDir = target.transform.position - sender.transform.position;
targetDir.y = 0;
Vector3 senderDir = sender.transform.rotation * Vector3.forward;
if (Mathf.Abs(Vector3.Angle(targetDir, senderDir)) > SectorDegree)
{
index++;
continue;
}
ImpactInfo curImpact = ExtractBestImpactInfo(target, impacts);
if (curImpact != null)
{
Vector3 faceDir = target.transform.position - sender.transform.position;
faceDir.y = 0;
ImpactInfo m_ImpactInfo = curImpact.Clone() as ImpactInfo;
m_ImpactInfo.m_Velocity = Quaternion.LookRotation(faceDir)
* m_ImpactInfo.m_Velocity;
m_ImpactInfo.Attacker = sender;
ImpactSystem.Instance.SendImpact(attacker, target, m_ImpactInfo, hitCount);
TriggerImpl.RecordTarget(attacker, target);
isTargeted = true;
}
}
index++;
}
ProcessImpactLock(attacker, impacts, isTargeted);
}
private void HoldWeapon(WeaponHand type, SkillWeaponInfo info)
{
GameObject newWeapon = CreateNewWeapon(info);
if (newWeapon != null)
{
#if SHOOTER_LOG
Debug.Log("HoldWeapon:" + newWeapon.name);
#endif
m_Weapons.Add(info.HoldType, newWeapon);
Script_Util.AttachGameObject(this.gameObject, newWeapon, GetBoneName(info.HoldType));
}
}
private void AdjustTargetPos()
{
float weaponHeight = TriggerImpl.GetWeaponHeight(this.gameObject);
Vector3 adjustTargetPos = Script_Util.AdjustTargetPos(
this.gameObject.transform,
TargetPos,
Camera.main.transform,
weaponHeight,
GunRotate);
//Debug.Log(string.Format("AdjustTargetPos TargetPos:{0} adjustTargetPos:{1} weaponHeight:{2}",
// TargetPos, adjustTargetPos, weaponHeight));
TriggerImpl.SetFacePos(this.gameObject, adjustTargetPos, YRotateRange);
}
private GameObject CreateNewWeapon(SkillWeaponInfo info)
{
GameObject tWeaponObj = null;
if (info.WeaponAsset != null)
{
tWeaponObj = Script_Util.CreateGameObjectByAsset(info.WeaponAsset);
}
else
{
tWeaponObj = Script_Util.CreateGameObjectByName(info.WeaponName);
}
return(tWeaponObj);
}
private void StartMove()
{
Ray ray = new Ray(m_BulletInfo.MoveStartPos, m_BulletInfo.MoveDir);
if (Physics.Raycast(ray, out m_MoveHitInfo, m_BulletInfo.MoveDistanceMax, (int)SceneLayerType.SceneStatic))
{
m_IsHit = true;
m_HitPos = m_MoveHitInfo.point;
}
else
{
m_IsHit = false;
m_HitPos = Script_Util.CaculateRelativePos(m_BulletInfo.MoveStartPos,
m_BulletInfo.MoveDir, m_BulletInfo.MoveDistanceMax);
}
}
private void ProcessMove()
{
if (m_IsMoving)
{
m_MoveElapsed += Time.deltaTime;
if (m_MoveElapsed < m_MoveDuration)
{
Vector3 curPos = Script_Util.CaculateFlyPos(m_BulletInfo.MoveStartPos,
m_BulletInfo.MoveDir, m_BulletInfo.MoveSpeed, m_MoveElapsed);
gameObject.transform.position = curPos;
}
else
{
StopMove();
}
}
}
public SkillMovementInfo(string param)
{
string[] result = Script_Util.SplitParam(param, 1);
if (result != null)
{
Id = Convert.ToInt32(result[0]);
MoveTimeMax = Convert.ToSingle(result[1]);
ForwardInfo = new NumericMovementInfo(result[2]);
UpwardInfo = new NumericMovementInfo(result[3]);
SidewardInfo = new NumericMovementInfo(result[4]);
Gravity = Script_Util.ToVector3(result[5]);
IsAppendVelocity = Convert.ToBoolean(result[6]);
}
else
{
IsValid = false;
}
}
private List <RaycastHit> CheckTarget(List <RaycastHit> hitInfos, SkillImpactInfos impact)
{
List <RaycastHit> retInfos = new List <RaycastHit>();
foreach (RaycastHit hitinfo in hitInfos)
{
GameObject target = hitinfo.transform.gameObject;
if (Script_Util.IsChildGameObject(GetAttacker(), target.GetInstanceID()))
{
continue;
}
if (TriggerImpl.CheckTargetInImpactExcept(target, impact))
{
continue;
}
retInfos.Add(hitinfo);
}
return(retInfos);
}
public SkillSceneObjInfo(string param)
{
string[] result = Script_Util.SplitParam(param, 1);
if (result != null)
{
Id = Convert.ToInt32(result[0]);
if (result.Length > 1)
{
for (int index = 1; index < result.Length; index++)
{
paramOther.Add(result[index]);
}
}
}
else
{
IsValid = false;
}
}
public SkillWeaponInfo(string param)
{
string[] result = Script_Util.SplitParam(param, 6);
if (result != null)
{
Id = Convert.ToInt32(result[0]);
WeaponName = result[1];
Operate = (WeaponCmd)Convert.ToInt32(result[2]);
HoldType = (WeaponHand)Convert.ToInt32(result[3]);
IsCurWeapon = Convert.ToBoolean(result[4]);
IsCurSubWeapon = Convert.ToBoolean(result[5]);
if (result.Length > 6)
{
SpriteName = result[6];
}
}
else
{
IsValid = false;
}
}
private void ProcessImpact()
{
if (m_TargetHitInfos != null)
{
m_TargetHitInfos.Clear();
}
Vector3 rayDirRevert = m_BulletInfo.MoveDir * (-1);
Vector3 impactScrPos = m_BulletInfo.ImpactSrcPos + rayDirRevert * m_BulletInfo.ImpactInfos.ImpactRadius;
Ray ray = new Ray(impactScrPos, m_BulletInfo.MoveDir);
float distance = (m_HitPos - m_BulletInfo.ImpactSrcPos).magnitude;
RaycastHit[] targetHitInfos = Physics.SphereCastAll(ray, m_BulletInfo.ImpactInfos.ImpactRadius,
distance, (int)SceneLayerType.Character);
Script_Util.DrawPhysicsSphereCastLine(ray, distance, m_BulletInfo.ImpactInfos.ImpactRadius, Color.red, 10.0f);
if (targetHitInfos != null && targetHitInfos.Length > 0)
{
m_TargetHitInfos = new List <RaycastHit>(targetHitInfos);
m_TargetHitInfos = CheckTarget(m_TargetHitInfos, m_BulletInfo.ImpactInfos);
foreach (RaycastHit hitInfo in m_TargetHitInfos)
{
GameObject target = hitInfo.transform.gameObject;
if (target != null)
{
ImpactInfo tImpactInfo = TriggerImpl.ExtractBestImpactInfo(target, m_BulletInfo.ImpactInfos);
if (tImpactInfo != null)
{
tImpactInfo = tImpactInfo.Clone() as ImpactInfo;
Script_Util.AdjustImpactEffectDataPos(target, GetAttacker(), tImpactInfo, hitInfo.point, m_BulletInfo.MoveDir);
Vector3 faceDir = m_BulletInfo.MoveDir;
faceDir.y = 0;
tImpactInfo.m_Velocity = Quaternion.LookRotation(faceDir) * tImpactInfo.m_Velocity;
tImpactInfo.Attacker = GetAttacker();
ImpactSystem.Instance.SendImpact(GetAttacker(), target, tImpactInfo);
TriggerImpl.RecordTarget(GetAttacker(), target);
}
}
}
}
}
//////////////////////////////////////////////////////////////////////////
// Effect
public static GameObject PlayEffect(SkillEffectInfo info)
{
GameObject tEffectObj = null;
if (info.EffectAsset != null)
{
tEffectObj = Script_Util.CreateGameObjectByAsset(info.EffectAsset);
}
else
{
tEffectObj = Script_Util.CreateGameObjectByName(info.EffectName);
}
if (tEffectObj != null)
{
tEffectObj.transform.rotation = Quaternion.Euler(info.EffectRot);
tEffectObj.transform.position = info.EffectPos;
if (tEffectObj.particleSystem != null)
{
tEffectObj.particleSystem.Play(true);
}
if (OnGetSkillSoundInfo != null)
{
SkillSoundInfo sInfo = OnGetSkillSoundInfo(info.EffectSoundId);
if (sInfo != null)
{
TriggerImpl.PlaySoundAtTarget(tEffectObj, sInfo);
}
}
GameObject.Destroy(tEffectObj, Script_Util.ForceNotifyEffectTime(info.EffectLiftTime));
}
else
{
LogicSystem.GfxLog("PlayEffect create failed!");
}
return(tEffectObj);
}
/// param:Id[对应到SkillSceneObjManager中的AttractBullet Id]
/// example:1
public void Trigger_AttractShoot(string param)
{
#if SHOOTER_LOG
Debug.Log("Trigger_AttractShoot param:" + param);
#endif
if (m_SceneObjMgr != null)
{
SkillSceneObjInfo sobjInfo = new SkillSceneObjInfo(param);
SceneObject_AttractBulletInfo bulletInfo = m_SceneObjMgr.TryGetAttractBulletInfo(sobjInfo.Id);
MasterWeaponType masterType = (MasterWeaponType)(sobjInfo.ExtractNumeric <int>(0, 0));
GameObject curMainWeapon = TriggerImpl.GetCurMainWeapon(this.gameObject, masterType);
if (bulletInfo != null && bulletInfo.SceneObjInfo != null && curMainWeapon != null)
{
Transform efSpark = LogicSystem.FindChildRecursive(curMainWeapon.transform,
Script_Util.ForceNotifyEffectBone(bulletInfo.SceneObjInfo.EffectParentBone));
if (null == efSpark)
{
Debug.Log("Trigger_AttractShoot bone miss!");
return;
}
bulletInfo = bulletInfo.Clone();
bulletInfo.Attacker = this.gameObject;
bulletInfo.SceneObjInfo.EffectPos += efSpark.transform.position;
bulletInfo.MoveStartPos += efSpark.transform.position;
bulletInfo.MoveDir = Quaternion.Euler(efSpark.transform.rotation.eulerAngles + bulletInfo.MoveDir) * Vector3.forward;
bulletInfo.SceneObjInfo.EffectLiftTime = float.MaxValue;
bulletInfo.ImpactSrcPos += new Vector3(gameObject.transform.position.x,
efSpark.transform.position.y, gameObject.transform.position.z);
GameObject tBulletObj = TriggerImpl.PlayEffect(bulletInfo.SceneObjInfo);
tBulletObj.SendMessage("Active", bulletInfo);
}
else
{
Debug.Log("Trigger_AttractShoot null!");
}
}
}
public static GameObject AttachEffectDirect(SkillEffectInfo info)
{
GameObject tEffectObj = null;
if (info.EffectAsset != null)
{
tEffectObj = Script_Util.CreateGameObjectByAsset(info.EffectAsset);
}
else
{
tEffectObj = Script_Util.CreateGameObjectByName(info.EffectName);
}
if (null != tEffectObj)
{
bool ret = Script_Util.AttachGameObjectDirect(info.EffectParent, tEffectObj.transform);
if (ret)
{
tEffectObj.transform.localPosition = info.EffectPos;
tEffectObj.transform.localRotation = Quaternion.Euler(info.EffectRot);
}
if (OnGetSkillSoundInfo != null)
{
SkillSoundInfo sInfo = OnGetSkillSoundInfo(info.EffectSoundId);
if (sInfo != null)
{
TriggerImpl.PlaySoundAtTarget(tEffectObj, sInfo);
}
}
GameObject.Destroy(tEffectObj, Script_Util.ForceNotifyEffectTime(info.EffectLiftTime));
}
else
{
LogicSystem.GfxLog("AttachEffect effect create failed!");
}
return(tEffectObj);
}
public SkillEffectInfo(string param)
{
string[] result = Script_Util.SplitParam(param, 1);
if (result != null)
{
Id = Convert.ToInt32(result[0]);
if (result.Length >= 2)
{
EffectName = result[1];
}
if (result.Length >= 3)
{
EffectLiftTime = Convert.ToSingle(result[2]);
}
if (result.Length >= 4)
{
EffectPos = Script_Util.ToVector3(result[3]);
}
if (result.Length >= 5)
{
EffectRot = Script_Util.ToVector3(result[4]);
}
if (result.Length >= 6)
{
EffectParentBone = result[5];
}
if (result.Length >= 7)
{
EffectSoundId = Convert.ToInt32(result[6]);
}
}
else
{
IsValid = false;
}
}
