public override int RefixHpDamage(CharacterInfo obj, int impactId, int hpDamage, int senderId, ref bool isCritical, int impactOwnerId)
{
ImpactInfo impactInfo = obj.GetSkillStateInfo().GetImpactInfoById(impactId);
if (null != impactInfo)
{
SuperArmorShieldInfo info = impactInfo.LogicDatas.GetData <SuperArmorShieldInfo>();
if (null != info)
{
info.DamageRemain -= hpDamage;
if (info.DamageRemain > 0)
{
if (null != EventUpdateSuperArmorShield)
{
EventUpdateSuperArmorShield(obj, impactId);
}
if (!obj.UltraArmor)
{
obj.UltraArmor = true;
}
}
else
{
if (null != EventStopSuperArmorShield)
{
EventStopSuperArmorShield(obj, impactId);
}
impactInfo.m_IsActivated = false;
obj.UltraArmor = false;
}
}
}
return(hpDamage);
}
public override void StartImpact(CharacterInfo obj, int impactId)
{
if (null != obj)
{
ImpactInfo impactInfo = obj.GetSkillStateInfo().GetImpactInfoById(impactId);
if (null != impactInfo)
{
obj.UltraArmor = true;
if (impactInfo.ConfigData.ParamNum > 1)
{
SuperArmorShieldInfo info = impactInfo.LogicDatas.GetData <SuperArmorShieldInfo>();
if (null == info)
{
info = new SuperArmorShieldInfo();
impactInfo.LogicDatas.AddData <SuperArmorShieldInfo>(info);
}
info.DamageRemain = (int)(float.Parse(impactInfo.ConfigData.ExtraParams[0]) * obj.GetActualProperty().HpMax);
info.DamageMax = info.DamageRemain;
info.EffectPath = impactInfo.ConfigData.ExtraParams[1];
if (null != EventStartSuperArmorShield)
{
EventStartSuperArmorShield(obj, impactId);
}
}
}
}
}
public override void Tick(CharacterInfo character, int impactId)
{
ImpactInfo impactInfo = character.GetSkillStateInfo().GetImpactInfoById(impactId);
if (null != impactInfo)
{
if (impactInfo.m_IsActivated)
{
float damageDelayTime = float.Parse(impactInfo.ConfigData.ExtraParams[0]);
if (damageDelayTime > 0.01f && TimeUtility.GetServerMilliseconds() > impactInfo.m_StartTime + damageDelayTime * 1000 && !impactInfo.m_HasEffectApplyed)
{
int curdamage = 0;
int damage = int.Parse(impactInfo.ConfigData.ExtraParams[1]);
if (!character.IsHaveStateFlag(CharacterState_Type.CST_Invincible))
{
ApplyDamage(character, impactId, out curdamage);
}
impactInfo.m_HasEffectApplyed = true;
ApplyRage(character, impactInfo, curdamage);
}
if (TimeUtility.GetServerMilliseconds() > impactInfo.m_StartTime + impactInfo.m_ImpactDuration)
{
impactInfo.m_IsActivated = false;
}
}
}
}
// Update is called once per frame
void Update()
{
if (IsActive)
{
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, 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);
}
}
}
if (Time.time > m_LastTriggerTime + m_AnimationPlayer.AnimationLenth(m_NormalAttackAnim.name))
{
StopSkill();
}
}
}
private void OnSendImpact(CharacterInfo sender, int targetId, int impactId, Vector3 srcPos, float srcDir)
{
CharacterView senderView = EntityManager.Instance.GetCharacterViewById(sender.GetId());
CharacterView targetView = EntityManager.Instance.GetCharacterViewById(targetId);
if (null != senderView && null != targetView)
{
CharacterInfo target = WorldSystem.Instance.GetCharacterById(targetId);
if (null != target)
{
// 施法者能造成硬直且受击方没有霸体
ImpactInfo impactInfo = target.GetSkillStateInfo().GetImpactInfoById(impactId);
if (null == impactInfo)
{
return;
}
int forceLogicId = -1;
if (sender.CauseStiff && !target.SuperArmor && !target.UltraArmor)
{
// 正常造成硬直
}
else
{
forceLogicId = 0;
impactInfo.m_IsGfxControl = false;
}
// Npc需要根据体型和类型判定
if (target.IsNpc)
{
NpcInfo npcInfo = target.CastNpcInfo();
// 场景破坏物体单独处理
if (npcInfo.NpcType == (int)NpcTypeEnum.SceneObject)
{
forceLogicId = 1;
impactInfo.m_IsGfxControl = true;
}
// 处理体型
if (!impactInfo.ConfigData.TargetFigure.Contains(npcInfo.NpcFigure))
{
forceLogicId = 0;
impactInfo.m_IsGfxControl = false;
}
}
// 打断技能
if ((null != impactInfo && 0 != impactInfo.ConfigData.ImpactGfxLogicId && forceLogicId < 0) || forceLogicId > 0)
{
if (null != target.SkillController)
{
target.SkillController.ForceInterruptCurSkill();
}
else
{
LogSystem.Warn("{0} does't have a skillcontroller", target.GetName());
}
}
GfxSystem.QueueGfxAction(GfxModule.Impact.GfxImpactSystem.Instance.SendImpactToCharacter, senderView.Actor, targetView.Actor, impactId, srcPos.X, srcPos.Y, srcPos.Z, srcDir, forceLogicId);
}
}
}
private bool IsBreakEndure(ImpactInfo impactInfo)
{
if (ImpactType.MicroGHitFly == impactInfo.m_Type)
{
return(true);
}
return(false);
}
public ActionResult DeleteConfirmed(int id)
{
ImpactInfo impactInfo = db.ImpactInfoes.Find(id);
db.ImpactInfoes.Remove(impactInfo);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public override void OnAddImpact(CharacterInfo obj, int impactId, int addImpactId)
{
ImpactInfo impactInfo = obj.GetSkillStateInfo().GetImpactInfoById(impactId);
if (null != impactInfo)
{
if (impactInfo.m_IsActivated)
{
ImpactInfo addImpactInfo = obj.GetSkillStateInfo().GetImpactInfoById(addImpactId);
if (null != addImpactInfo)
{
if (addImpactInfo.m_ImpactSenderId == obj.GetId())
{
return;
}
if (impactInfo.ConfigData.ParamNum >= 4)
{
int beatSkillId = int.Parse(impactInfo.ConfigData.ExtraParams[0]);
int blockImpactId = int.Parse(impactInfo.ConfigData.ExtraParams[1]);
string EffectAndBone = impactInfo.ConfigData.ExtraParams[2];
float maxDis = float.Parse(impactInfo.ConfigData.ExtraParams[3]);
CharacterInfo target = obj.SceneContext.GetCharacterInfoById(addImpactInfo.m_ImpactSenderId);
if (null != target)
{
Vector3 srcPos = obj.GetMovementStateInfo().GetPosition3D();
Vector3 tarPos = target.GetMovementStateInfo().GetPosition3D();
if (Geometry.DistanceSquare(srcPos, tarPos) < maxDis * maxDis)
{
ImpactSystem.Instance.SendImpactToCharacter(obj,
blockImpactId,
addImpactInfo.m_ImpactSenderId,
-1,
-1,
srcPos,
obj.GetMovementStateInfo().GetFaceDir());
}
ImpactSystem.Instance.StopImpactById(obj, impactId);
impactInfo.m_IsActivated = false;
//obj.SuperArmor = false;
if (null != EventImpactLogicSkill)
{
EventImpactLogicSkill(obj, beatSkillId);
}
if (null != EventImpactLogicEffect)
{
string[] EffectBonePair = EffectAndBone.Split('|');
if (EffectBonePair.Length >= 2)
{
EventImpactLogicEffect(obj, EffectBonePair[0], EffectBonePair[1], 2.0f);
}
}
}
}
}
}
}
}
public void OnStiffness(ImpactInfo impactInfo)
{
m_ImpactInfo.m_EffectDatas.AddRange(impactInfo.m_EffectDatas);
if (m_IsActive)
{
m_AnimationPlayer.SetAnimationState(m_AnimationDict.FlyHitAnim.name, 1, 1.0f, 1.0f, AnimationBlendMode.Additive);
m_AnimationPlayer.Play(m_AnimationDict.FlyHitAnim.name);
}
}
private void OnHitTarget(GameObject obj)
{
ImpactInfo impact = m_ImpactInfo.Clone() as ImpactInfo;
impact.Attacker = m_Sender;
impact.m_Velocity = this.transform.forward * impact.m_Velocity.z;
ImpactSystem.Instance.SendImpact(m_Sender, obj, impact.Clone() as ImpactInfo);
ResourceSystem.RecycleObject(gameObject);
}
public void StartImpact(ImpactInfo impactInfo)
{
if (null == impactInfo)
{
Debug.LogWarning("ImpactComa::StartImpact -- impactInfo is null");
}
m_AnimationPlayer.CrossFade(m_ComaAnim.name);
GeneralStartImpact(impactInfo);
}
public virtual void ensureDataConsistency()
{
if (impactInfo == null)
impactInfo = new ImpactInfo();
animUtils = GetComponent<AnimatorUtils>() ?? gameObject.AddComponent<AnimatorUtils>();
animUtils.setTextsDelegate(getDescriptionTexts);
animUtils.DescriptionEditingAllowed = false;
}
private Impact CreateSkillImpact(ImpactInfo info_)
{
SkillImpactData data = Main.Inst.Data.Get <SkillImpactData>(info_.impactObjectId);
SkillImpact impact = new SkillImpact(data.targetTypes, data.value, data.skills)
{
Strategy = data.strategy,
};
return(impact);
}
// Use this for initialization
void Start()
{
impactInfoList = new List <ImpactInfo>(100);
//
robotControl = FindObjectOfType <RobotControl>();
// Iniciamos el de rapid fire
rapidFireImpactInfo = new ImpactInfo();
rapidFireImpactInfo.info = 0 + "";
//
mainCamera = Camera.main;
}
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);
}
public Impact Create(ImpactInfo info_)
{
if (_factoryFuncs.ContainsKey(info_.impactType))
{
return(_factoryFuncs[info_.impactType].Invoke(info_));
}
else
{
Debug.LogError(this.GetType().Name + ": Can't create impact of type:" + info_.impactType);
return(null);
}
}
public void StartImpact(ImpactInfo impactInfo)
{
if (null == impactInfo)
{
Debug.LogWarning("ImpactThunderStroke::StartImpact -- impactInfo is null");
}
GeneralStartImpact(impactInfo);
m_AnimationPlayer.SetAnimationState(m_StrokeAnim.name, 10, 1.0f, 1.0f, AnimationBlendMode.Additive);
m_AnimationPlayer.Play(m_StrokeAnim.name);
m_LastStrokeTime = Time.time;
m_ImpactInfo.m_ThunderStrokeConfig.m_StrokeCount--;
}
public ActionResult Assign([Bind(Include = "Impactid, TicketId,FaultId,TroubleshooterId,TicketRaisedDate,TicketClosingDate")] ImpactInfo impactInfo)
{
if (ModelState.IsValid)
{
Troubleshooter troubleshooter = db.Troubleshooters.Find(impactInfo.TroubleshooterId);
impactInfo.TeamId = troubleshooter.TroubleshooterTeam;
db.ImpactInfoes.Add(impactInfo);
db.SaveChanges();
return(RedirectToAction("Index", "ImpactInfoes"));
}
return(View(impactInfo));
}
//
public void SendImpactInfo(Vector3 point, int damageReceived, string extraInfo = "")
{
// TODO: Sacar los del player para manejar los de fuego rápido por separado
// Cribamos valores bajos de momento
//if (damageReceived < 1) return;
//
Vector3 screenPosition = mainCamera.WorldToScreenPoint(point);
if (screenPosition.z < 0)
{
return;
}
//
//if (!CheckIfPlayerInRapidFire())
//{
//
ImpactInfo newImpactInfo = new ImpactInfo();
newImpactInfo.damageValue = damageReceived;
//newImpactInfo.info = force + " N";
newImpactInfo.info = damageReceived + "";
newImpactInfo.extraInfo = extraInfo;
newImpactInfo.position = point;
newImpactInfo.screenPosition = screenPosition;
newImpactInfo.textColor = new Color(UnityEngine.Random.Range(0, 1.0f),
UnityEngine.Random.Range(0, 1.0f),
UnityEngine.Random.Range(0, 1.0f));
// TODO: Esto parece sobrar
// Asegurarse de que es necesario
if (newImpactInfo != null)
{
impactInfoList.Add(newImpactInfo);
}
//}
//else
//{
// rapidFireImpactInfo.damageValue += damageReceived;
// rapidFireImpactInfo.info = Int32.Parse(rapidFireImpactInfo.info) + damageReceived + "";
// rapidFireImpactInfo.extraInfo = extraInfo;
// rapidFireImpactInfo.position = point;
// rapidFireImpactInfo.screenPosition = screenPosition;
// //
// //rapidFireActive = true;
// rapidFireImpactInfo.timeAlive = 0;
//}
}
private void SendGrabImpact(GameObject obj, ImpactInfo impactInfo)
{
ImpactGrab grabLogic = obj.GetComponent <ImpactGrab>();
if (null != grabLogic)
{
if (!grabLogic.IsAcitve)
{
StopImpactExcept(obj, ImpactType.Grab);
grabLogic.StartImpact(impactInfo);
}
}
}
private void SendHitFlyImpact(GameObject obj, ImpactInfo impactInfo)
{
ImpactMicroGHitFly mircoGHitFly = obj.GetComponent <ImpactMicroGHitFly>();
ImpactHitFly hitFlyLogic = obj.GetComponent <ImpactHitFly>();
if (null != mircoGHitFly && mircoGHitFly.IsAcitve)
{
if (ImpactType.HitFly != mircoGHitFly.GetImpactType())
{
mircoGHitFly.StopImpact();
if (null != hitFlyLogic)
{
hitFlyLogic.StartImpact(impactInfo);
return;
}
}
else
{
mircoGHitFly.OnHitInFly();
}
return;
}
ImpactGrab grabLogic = obj.GetComponent <ImpactGrab>();
if (null != grabLogic && grabLogic.IsAcitve)
{
return;
}
ImpactKnockDown knockDownLogic = obj.GetComponent <ImpactKnockDown>();
if (null != knockDownLogic && knockDownLogic.IsAcitve)
{
knockDownLogic.StopImpact();
}
ImpactStiffness stiffnessLogic = obj.GetComponent <ImpactStiffness>();
if (null != stiffnessLogic && stiffnessLogic.IsAcitve)
{
stiffnessLogic.StopImpact();
}
if (null != hitFlyLogic)
{
/*if (hitFlyLogic.IsAcitve) {
* hitFlyLogic.OnHitInFly();
* return;
* }*/
hitFlyLogic.StopImpact();
hitFlyLogic.StartImpact(impactInfo);
}
}
public ActionResult Edit([Bind(Include = "Impactid,TicketId,TeamId,FaultId,TroubleshooterId,TicketRaisedDate,TicketClosingDate")] ImpactInfo impactInfo)
{
if (ModelState.IsValid)
{
db.Entry(impactInfo).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.FaultId = new SelectList(db.Faults, "FaultId", "FaultSeverity", impactInfo.FaultId);
ViewBag.TeamId = new SelectList(db.Teams, "TeamId", "TeamName", impactInfo.TeamId);
ViewBag.TicketId = new SelectList(db.TicketStatus, "TicketStausId", "TicketStatus", impactInfo.TicketId);
ViewBag.TroubleshooterId = new SelectList(db.Troubleshooters, "TroubleshooterId", "TroubleshooterName", impactInfo.TroubleshooterId);
return(View(impactInfo));
}
// GET: ImpactInfoes/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
ImpactInfo impactInfo = db.ImpactInfoes.Find(id);
if (impactInfo == null)
{
return(HttpNotFound());
}
return(View(impactInfo));
}
public override int RefixHpDamage(CharacterInfo obj, int impactId, int hpDamage, int senderId, ref bool isCritical, int impactOwnerId)
{
if (obj == null)
{
return(hpDamage);
}
if (impactOwnerId != senderId)
{
return(hpDamage);
}
CharacterInfo sender = obj.SceneContext.GetCharacterInfoById(senderId);
if (sender == null)
{
return(hpDamage);
}
CombatStatisticInfo combat_info = sender.GetCombatStatisticInfo();
if (combat_info == null)
{
return(hpDamage);
}
if (sender.TalentManager == null)
{
return(hpDamage);
}
KillAddDamage kill_attr = sender.TalentManager.GetTalentAttribute(AttributeId.kKillAddDamage) as KillAddDamage;
if (kill_attr == null || !kill_attr.IsActive)
{
return(hpDamage);
}
//LogSystem.Error("-----KillAddDamange: trigger hit {0} add damage hit {1}", kill_attr.KillHitCountId, combat_info.LastHitCountId);
if (kill_attr.IsDamageHit(combat_info.LastHitCountId))
{
hpDamage += kill_attr.DamageAdd;
//LogSystem.Error("-----KillAddDamange: add damage {0}!", kill_attr.DamageAdd);
}
else if (!kill_attr.IsTriggerHit(combat_info.LastHitCountId))
{
//LogSystem.Error("-----KillAddDamange: stopped! 1");
kill_attr.Refresh();
ImpactInfo impactInfo = obj.GetSkillStateInfo().GetImpactInfoById(impactId);
if (impactInfo != null)
{
impactInfo.m_IsActivated = false;
}
}
return(hpDamage);
}
public override void Tick(CharacterInfo obj, int impactId)
{
ImpactInfo impactInfo = obj.GetSkillStateInfo().GetImpactInfoById(impactId);
if (null != impactInfo)
{
if (impactInfo.m_IsActivated)
{
if (obj.Hp <= 0)
{
obj.SetHp(Operate_Type.OT_Absolute, 1);
}
}
}
}
public ImpactInfoWrapper(ImpactInfo impactInfo)
{
impactInfo.Validate("impactInfo");
this.ImpactAction = impactInfo.ImpactAction;
this.ImpactedResources = impactInfo.ImpactedResources != null
? impactInfo.ImpactedResources.Deserialize()
: new AffectedResourceImpact();
if (this.ImpactedResources.ListOfImpactTypes == null)
{
this.ImpactedResources.ListOfImpactTypes = new List <ImpactTypeEnum>();
}
}
public override void Tick(CharacterInfo character, int impactId)
{
ImpactInfo impactInfo = character.GetSkillStateInfo().GetImpactInfoById(impactId);
if (null != impactInfo)
{
if (impactInfo.m_IsActivated)
{
if (TimeUtility.GetServerMilliseconds() > impactInfo.m_StartTime + impactInfo.m_ImpactDuration)
{
impactInfo.m_IsActivated = false;
}
}
}
}
private void SendThunderStrokeImpact(GameObject obj, ImpactInfo impactInfo)
{
ImpactGrab grabLogic = obj.GetComponent <ImpactGrab>();
if (null != grabLogic && grabLogic.IsAcitve)
{
return;
}
ImpactThunderStroke thunderStrokeLogic = obj.GetComponent <ImpactThunderStroke>();
if (null != thunderStrokeLogic)
{
thunderStrokeLogic.StartImpact(impactInfo);
}
}
private void TryUpdateValue(StoryInstance instance)
{
int unitId = m_UnitId.Value;
int impactId = m_ImpactId.Value;
m_HaveValue = true;
EntityInfo entity = PluginFramework.Instance.GetEntityByUnitId(unitId);
if (null != entity) {
ImpactInfo impactInfo = entity.GetSkillStateInfo().FindImpactInfoById(impactId);
if (null != impactInfo) {
m_Value = impactInfo.Seq;
} else {
m_Value = 0;
}
}
}
public override int RefixHpDamage(CharacterInfo obj, int impactId, int hpDamage, int senderId, ref bool isCritical, int impactOwnerId)
{
if (null != obj)
{
ImpactInfo impactInfo = obj.GetSkillStateInfo().GetImpactInfoById(impactId);
if (null != impactInfo)
{
if (impactInfo.ConfigData.ExtraParams.Count > 0)
{
float damageRate = float.Parse(impactInfo.ConfigData.ExtraParams[0]);
hpDamage = (int)(hpDamage * damageRate);
}
}
}
return(hpDamage);
}
public static void ProcessImpactByBoxCollider(GameObject attacker, GameObject sender,
SkillImpactInfos impacts, Vector3 center, Vector3 size, int hitCount = 1)
{
bool isTargeted = false;
// Find Targets
Bounds bounds = new Bounds(center, size);
Collider[] hitColliders = Physics.OverlapSphere(sender.transform.position,
impacts.ImpactRadius, (int)SceneLayerType.Character);
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 (bounds != null && !IsPointInBounds(sender, target, bounds))
{
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);
}
internal static void Execute(object msg, NetConnection conn)
{
Msg_RC_AddImpact message = msg as Msg_RC_AddImpact;
if (null == message) return;
int skillId = message.skill_id;
int impactId = message.impact_id;
EntityInfo target = ClientModule.Instance.SceneContext.GetEntityById(message.target_id);
if (null == target) {
LogSystem.Info("Receive Msg_RC_AddImpact, message.target_id={0} is not available", message.target_id);
return;
} else {
LogSystem.Info("Receive Msg_RC_AddImpact, TargetId={0}, ImpactId={1}, SenderId={2}, SkillId={3}",
message.target_id, impactId, message.sender_id, skillId);
}
Vector3 senderPos = Vector3.Zero;
EntityInfo sender = ClientModule.Instance.GetEntityById(message.sender_id);
senderPos = sender.GetMovementStateInfo().GetPosition3D();
ImpactInfo impactInfo = new ImpactInfo(impactId);
impactInfo.StartTime = TimeUtility.GetLocalMilliseconds();
impactInfo.SkillId = skillId;
impactInfo.DurationTime = message.duration;
impactInfo.SenderPosition = senderPos;
impactInfo.ImpactSenderId = message.sender_id;
if (null != impactInfo.ConfigData) {
target.GetSkillStateInfo().AddImpact(impactInfo);
int seq = impactInfo.Seq;
if (GfxSkillSystem.Instance.StartSkill(target.GetId(), impactInfo.ConfigData, seq)) {
}
}
}
