public void ReadySkillCheck(ReadySkillCheckInfo info)
{
Skill skillOrAttackById = this.self.getSkillOrAttackById(info.skillId);
Units units = null;
if (info.targetUnits != null && info.targetUnits.Count > 0)
{
units = MapManager.Instance.GetUnit((int)info.targetUnits[0]);
}
if (null == units && ((skillOrAttackById.needTarget && skillOrAttackById.IsSkill) || skillOrAttackById.IsAttack))
{
ClientLogger.Error("Recv ReadySkillCheck target null: " + info);
return;
}
if (info.checkSuccess)
{
if (skillOrAttackById.IsAttack)
{
this.ComboAttack_Impl(skillOrAttackById.skillIndex, units, false);
}
else if (info.targetPosition == null)
{
this.Conjure_Impl(info.skillId, units, null, false);
}
else
{
this.Conjure_Impl(info.skillId, units, new Vector3?(MoveController.SVectgor3ToVector3(info.targetPosition)), false);
}
}
else if (info.targetPosition != null && units != null)
{
units.transform.position = MoveController.SVectgor3ToVector3(info.targetPosition);
}
}
public static void SendReadySkillCheckEvent(ReadySkillCheckInfo info)
{
byte[] args = SerializeHelper.Serialize <ReadySkillCheckInfo>(info);
SendMsgManager.Instance.SendPvpMsg(PvpCode.C2P_ReadySkillCheck, args);
}
public void ComboAttack(int index, Units target)
{
if (Singleton <PvpManager> .Instance.IsInPvp)
{
if (this.self.CanAttack && !this.isComboAttack)
{
Skill attackByIndex = this.self.getAttackByIndex(index);
if (attackByIndex == null)
{
ClientLogger.Error(" ComboAttack Error : attack " + index + " is NULL !");
base.OnAttackFailedBeforeStart(null);
return;
}
if (!this.sendUseSkillTicks.ContainsKey(attackByIndex.skillMainId))
{
this.sendUseSkillTicks.Add(attackByIndex.skillMainId, 0L);
}
if (!this.sendUseSkills.ContainsKey(attackByIndex.skillMainId))
{
this.sendUseSkills.Add(attackByIndex.skillMainId, false);
}
if (DateTime.Now.Ticks - this.sendUseSkillTicks[attackByIndex.skillMainId] > 5000000L)
{
this.sendUseSkills[attackByIndex.skillMainId] = false;
}
if (this.sendUseSkills[attackByIndex.skillMainId])
{
return;
}
if (target == null)
{
target = this.self.GetAttackTarget();
}
if (PvpServerStartSkillHeroList.IsStartByServer(this.self.npc_id))
{
this.ComboAttack_Impl(index, target, true);
}
else
{
ReadySkillCheckInfo readySkillCheckInfo = new ReadySkillCheckInfo();
readySkillCheckInfo.unitId = this.self.unique_id;
readySkillCheckInfo.skillId = attackByIndex.skillMainId;
List <short> list = new List <short>();
if (null != target)
{
list.Add((short)target.unique_id);
}
readySkillCheckInfo.targetUnits = list;
PvpEvent.SendReadySkillCheckEvent(readySkillCheckInfo);
}
}
else
{
base.OnAttackFailedBeforeStart(this.self.getAttackByIndex(0));
}
}
else
{
this.ComboAttack_Impl(index, target, false);
}
}
public override void Conjure(string skillId, Units target = null, Vector3?targetPos = null)
{
this.self.InterruptConjure(SkillInterruptType.Initiative);
Skill skillById = this.self.getSkillById(skillId);
if (!skillById.CheckCD(false))
{
Singleton <TriggerManager> .Instance.SendUnitSkillStateEvent(UnitEvent.UnitSkillCmdFailed, this.self, skillById);
return;
}
if (!this.sendUseSkillTicks.ContainsKey(skillId))
{
this.sendUseSkillTicks.Add(skillId, 0L);
}
if (!this.sendUseSkills.ContainsKey(skillId))
{
this.sendUseSkills.Add(skillId, false);
}
if (DateTime.Now.Ticks - this.sendUseSkillTicks[skillId] > 5000000L)
{
this.sendUseSkills[skillId] = false;
}
if (this.sendUseSkills[skillId])
{
Singleton <TriggerManager> .Instance.SendUnitSkillStateEvent(UnitEvent.UnitSkillCmdFailed, this.self, skillById);
return;
}
if (targetPos.HasValue)
{
float y = AstarPath.active.GetPosHeight(targetPos.Value) + 0.05f;
targetPos = new Vector3?(new Vector3(targetPos.Value.x, y, targetPos.Value.z));
}
if (this.self.CanSkill || skillById.CheckSkillCanUseSpecial)
{
if (target == null && !targetPos.HasValue)
{
target = this.self.GetAttackTarget();
}
skillById.attackTarget = target;
skillById.attackPosition = targetPos;
skillById.externalPostion = targetPos;
if (Singleton <PvpManager> .Instance.IsInPvp && this.self.isPlayer)
{
if (PvpServerStartSkillHeroList.IsStartByServer(this.self.npc_id))
{
this.Conjure_Impl(skillId, target, targetPos, true);
}
else if (UnitsSnapReporter.Instance.NetworkDelayInMs > 400L || UnityEngine.Random.Range(0, 100) > 90)
{
ReadySkillCheckInfo readySkillCheckInfo = new ReadySkillCheckInfo();
readySkillCheckInfo.unitId = this.self.unique_id;
readySkillCheckInfo.skillId = skillId;
List <Units> skillTargets = skillById.GetSkillTargets();
if (targetPos.HasValue)
{
readySkillCheckInfo.targetPosition = MoveController.Vector3ToSVector3(targetPos.Value);
}
List <short> list = new List <short>();
foreach (Units current in skillTargets)
{
list.Add((short)current.unique_id);
}
readySkillCheckInfo.targetUnits = list;
PvpEvent.SendReadySkillCheckEvent(readySkillCheckInfo);
this.sendUseSkills[skillId] = true;
this.sendUseSkillTicks[skillId] = DateTime.Now.Ticks;
}
else
{
this.Conjure_Impl(skillId, target, targetPos, false);
}
}
else
{
this.Conjure_Impl(skillId, target, targetPos, false);
}
}
else
{
Singleton <TriggerManager> .Instance.SendUnitSkillStateEvent(UnitEvent.UnitSkillCmdFailed, this.self, skillById);
}
}
