protected void InitMovement(ImpactLogicInfo info)
{
ImpactLogicData config = info.ConfigData;
if (null != config)
{
switch ((ImpactMovementType)config.MoveMode)
{
case ImpactMovementType.SenderDir:
if (null != info.Sender)
{
info.MoveDir = UnityEngine.Quaternion.Euler(0, ImpactUtility.RadianToDegree(info.ImpactSrcDir), 0);
}
break;
case ImpactMovementType.SenderToTarget:
if (null != info.Target)
{
UnityEngine.Vector3 direction = info.Target.transform.position - info.ImpactSrcPos;
direction.y = 0.0f;
direction.Normalize();
info.MoveDir = UnityEngine.Quaternion.LookRotation(direction);
}
break;
case ImpactMovementType.Inherit:
if (null != info.Sender)
{
info.MoveDir = UnityEngine.Quaternion.Euler(0, ImpactUtility.RadianToDegree(info.ImpactSrcDir), 0);
}
break;
}
}
}
public void Init()
{
impactLogicDataCacheCont = new MyDictionary <int, ImpactCacheData>();
MyDictionary <int, object> datacont = SkillConfigProvider.Instance.impactLogicDataMgr.GetData();
foreach (KeyValuePair <int, object> pair in datacont)
{
int id = pair.Key;
ImpactLogicData ild = pair.Value as ImpactLogicData;
ImpactCacheData idlc = new ImpactCacheData();
idlc.CurveAnimationInfo = new CurveInfo(ild.AnimationInfo);
idlc.CurveLockFrameInfo = new CurveInfo(ild.LockFrameInfo);
idlc.CurveMovementInfo = new CurveMoveInfo(ild.CurveMoveInfo);
idlc.MoveInfolist = Converter.ConvertNumericList <float>(ild.CurveMoveInfo);
if (!String.IsNullOrEmpty(ild.AdjustPoint))
{
idlc.AdjustPointV3 = ImpactUtility.ConvertVector3D(ild.AdjustPoint);
}
impactLogicDataCacheCont.Add(id, idlc);
}
m_ImpactLogicPool = new ObjectPool <ImpactLogicInfo>();
m_ImpactLogicPool.Init(128);
m_EffectInfoPool = new ObjectPool <EffectInfo>();
m_EffectInfoPool.Init(c_EffectPoolCapacity);
GfxImpactSoundManager.Instacne.Init();
}
public void TryPlaySound(GameObject target, string sound)
{
if (CanPlaySoundNow())
{
if (null != target)
{
ImpactUtility.PlaySound(target, sound);
RecordSoundPlay();
}
else
{
}
}
}
protected void Move(GameObject obj, UnityEngine.Vector3 motion)
{
if (null != obj)
{
SharedGameObjectInfo info = LogicSystem.GetSharedGameObjectInfo(obj);
if (null != info && info.CanHitMove)
{
while (motion.magnitude > m_MaxMoveStep)
{
UnityEngine.Vector3 childMotion = UnityEngine.Vector3.ClampMagnitude(motion, m_MaxMoveStep);
motion = motion - childMotion;
ImpactUtility.MoveObject(obj, childMotion);
}
ImpactUtility.MoveObject(obj, motion);
}
}
}
public void AddEffectData(int id)
{
EffectLogicData effectData = (EffectLogicData)SkillConfigProvider.Instance.ExtractData(SkillConfigType.SCT_EFFECT, id);
if (null != effectData)
{
EffectInfo effectInfo = new EffectInfo();
effectInfo.IsActive = false;
effectInfo.Path = effectData.EffectPath;
effectInfo.PlayTime = effectData.PlayTime;
effectInfo.RelativePoint = ImpactUtility.ConvertVector3D(effectData.RelativePos);
effectInfo.RotateWithTarget = effectData.RotateWithTarget;
effectInfo.RelativeRotation = ImpactUtility.ConvertVector3D(effectData.RelativeRotation);
effectInfo.MountPoint = effectData.MountPoint;
effectInfo.DelayTime = effectData.EffectDelay;
effectInfo.DelWithImpact = effectData.DelWithImpact;
m_EffectList.Add(effectInfo);
}
}
protected void ResetLayer(GameObject obj, ImpactLogicInfo info)
{
ImpactLogicData config = info.ConfigData;
if (null != config && config.IgnoreBlock)
{
if (null != obj)
{
SharedGameObjectInfo shareInfo = LogicSystem.GetSharedGameObjectInfo(obj);
if (null != shareInfo)
{
if (shareInfo.IsNpc)
{
ImpactUtility.SetLayer(obj, ImpactUtility.MonsterLayer);
}
else if (shareInfo.IsPlayer)
{
ImpactUtility.SetLayer(obj, ImpactUtility.PlayerLayer);
}
}
}
}
}
public virtual void UpdateEffect(ImpactLogicInfo logicInfo)
{
if (null == logicInfo.Target)
{
return;
}
SharedGameObjectInfo shareInfo = LogicSystem.GetSharedGameObjectInfo(logicInfo.Target);
if (null != shareInfo && !shareInfo.AcceptStiffEffect)
{
return;
}
for (int i = 0; i < logicInfo.EffectList.Count; ++i)
{
EffectInfo effectInfo = logicInfo.EffectList[i];
if (null != effectInfo)
{
if (effectInfo.StartTime < 0 && Time.time > logicInfo.StartTime + effectInfo.DelayTime / 1000)
{
effectInfo.IsActive = true;
effectInfo.StartTime = Time.time;
GameObject obj = ResourceSystem.NewObject(effectInfo.Path, effectInfo.PlayTime / 1000) as GameObject;
if (null != obj)
{
if (effectInfo.DelWithImpact)
{
logicInfo.EffectsDelWithImpact.Add(obj);
}
if (String.IsNullOrEmpty(effectInfo.MountPoint))
{
obj.transform.position = logicInfo.Target.transform.position + effectInfo.RelativePoint;
UnityEngine.Quaternion q = UnityEngine.Quaternion.Euler(effectInfo.RelativeRotation.x, effectInfo.RelativeRotation.y, effectInfo.RelativeRotation.z);
if (effectInfo.RotateWithTarget && null != logicInfo.Sender)
{
obj.transform.rotation = UnityEngine.Quaternion.LookRotation(logicInfo.Target.transform.position - logicInfo.Sender.transform.position, UnityEngine.Vector3.up);
obj.transform.rotation = UnityEngine.Quaternion.Euler(obj.transform.rotation.eulerAngles + effectInfo.RelativeRotation);
}
else
{
obj.transform.rotation = q;
}
}
else
{
Transform parent = LogicSystem.FindChildRecursive(logicInfo.Target.transform, effectInfo.MountPoint);
if (null != parent)
{
obj.transform.parent = parent;
obj.transform.localPosition = UnityEngine.Vector3.zero;
UnityEngine.Quaternion q = UnityEngine.Quaternion.Euler(ImpactUtility.RadianToDegree(effectInfo.RelativeRotation.x), ImpactUtility.RadianToDegree(effectInfo.RelativeRotation.y), ImpactUtility.RadianToDegree(effectInfo.RelativeRotation.z));
obj.transform.localRotation = q;
}
}
}
}
}
}
}
private void SendImpactToCharacterImpl(GameObject senderObj, GameObject targetObj, int impactId, float x, float y, float z, float dir, int forceLogicId)
{
ImpactLogicData config = SkillConfigProvider.Instance.ExtractData(SkillConfigType.SCT_IMPACT, impactId) as ImpactLogicData; if (null != config)
{
ImpactLogicInfo info = m_ImpactLogicPool.Alloc();
// ImpactLogicInfo info = new ImpactLogicInfo();
info.Sender = senderObj;
info.Target = targetObj;
info.ImpactId = impactId;
info.StartTime = Time.time;
info.LogicId = config.ImpactGfxLogicId;
if (-1 != forceLogicId)
{
info.LogicId = forceLogicId;
}
info.IsActive = true;
ImpactCacheData impactcachevalue;
if (impactLogicDataCacheCont.TryGetValue(impactId, out impactcachevalue))
{
info.AnimationInfo = impactcachevalue.CurveAnimationInfo;
info.LockFrameInfo = impactcachevalue.CurveLockFrameInfo;
info.MovementInfo = impactcachevalue.CurveMovementInfo;
info.ConfigCacheData = impactcachevalue;
}
else
{
info.AnimationInfo = new CurveInfo(config.AnimationInfo);
info.LockFrameInfo = new CurveInfo(config.LockFrameInfo);
info.MovementInfo = new CurveMoveInfo(config.CurveMoveInfo);
}
info.AdjustPoint = UnityEngine.Quaternion.Euler(0, ImpactUtility.RadianToDegree(dir), 0) * info.ConfigCacheData.AdjustPointV3 + new UnityEngine.Vector3(x, y, z);
info.AdjustAppend = config.AdjustAppend;
info.AdjustDegreeXZ = config.AdjustDegreeXZ;
info.AdjustDegreeY = config.AdjustDegreeY;
info.ConfigData = config;
info.Duration = config.ImpactTime / 1000;
info.ImpactSrcPos = new UnityEngine.Vector3(x, y, z);
info.ImpactSrcDir = dir;
info.NormalEndPoint = GetImpactEndPos(info.Target.transform.position, UnityEngine.Quaternion.Euler(0, ImpactUtility.RadianToDegree(info.ImpactSrcDir), 0), info);
info.NormalPos = info.Target.transform.position;
info.OrignalPos = info.Target.transform.position;
ShowDebugObject(info.AdjustPoint, 0);
ShowDebugObject(info.NormalEndPoint, 1);
for (int i = 0; i < config.EffectList.Count; i++)
{
if (config.EffectList[i].Count > 0)
{
if (c_EffectPoolCapacity - m_EffectInfoPool.Count < c_MaxHitEffect)
{
EffectInfo effectinfo = m_EffectInfoPool.Alloc();
info.AddEffectDataByinfo(config.EffectList[i][UnityEngine.Random.Range(0, config.EffectList[i].Count)], effectinfo);
}
else
{
}
}
}
AddImpactInfo(info);
IGfxImpactLogic logic = GfxImpactLogicManager.Instance.GetGfxImpactLogic(info.LogicId);
if (logic != null)
{
logic.StartImpact(info);
}
else
{
LogSystem.Debug("SendImpactToCharacter: Can't find impact logic {0}", info.LogicId);
}
}
}
