protected override void OnSendStart()
{
if (Singleton <PvpManager> .Instance.IsInPvp && PvpServerStartSkillHeroList.IsStartByServer(base.unit.npc_id))
{
return;
}
StartSkillInfo startSkillInfo = new StartSkillInfo();
startSkillInfo.unitId = base.unit.unique_id;
startSkillInfo.skillId = this.skillKey.SkillID;
Vector3?targetPosition = this.targetPosition;
if (targetPosition.HasValue)
{
startSkillInfo.targetPosition = MoveController.Vector3ToSVector3(this.targetPosition.Value);
}
List <short> list = null;
if (this.targetUnits != null)
{
list = new List <short>();
for (int i = 0; i < this.targetUnits.Count; i++)
{
list.Add((short)this.targetUnits[i].unique_id);
}
}
startSkillInfo.targetUnits = list;
PvpEvent.SendStartSkillEvent(startSkillInfo);
}
private void OnMsg_LoadView_setProgress(MobaMessage msg)
{
int num = 0;
MsgData_LoadView_setProgress msgData_LoadView_setProgress = msg.Param as MsgData_LoadView_setProgress;
if (msgData_LoadView_setProgress != null)
{
if (!Singleton <PvpManager> .Instance.IsObserver)
{
int myLobbyUserId = Singleton <PvpManager> .Instance.MyLobbyUserId;
if (msgData_LoadView_setProgress.AddType == MsgData_LoadView_setProgress.SetType.addNum)
{
num = this.SetComProgress(myLobbyUserId, msgData_LoadView_setProgress.Num, true);
}
else if (msgData_LoadView_setProgress.AddType == MsgData_LoadView_setProgress.SetType.targetNum)
{
num = this.SetComProgress(myLobbyUserId, msgData_LoadView_setProgress.Num, false);
}
HeroExtraInRoom heroExtraByUserId = Singleton <PvpManager> .Instance.RoomInfo.GetHeroExtraByUserId(myLobbyUserId);
if (heroExtraByUserId != null)
{
heroExtraByUserId.LoadProgress = num;
}
PvpEvent.SendLoadingProcessEvent((byte)num);
}
}
}
public void StopMoveForSkill()
{
if (!Singleton <PvpManager> .Instance.IsInPvp)
{
if (this.isMoving && this.navAgent != null)
{
this.navAgent.StopMove();
}
}
else if ((this.self.isHero || this.self.isPlayer) && this.isMoving)
{
StopMove data = new StopMove
{
rotate = this.self.transform.eulerAngles.y,
unitId = this.self.unique_id,
pos = MoveController.Vector3ToSVector3(this.self.transform.position),
tick = UnitsSnapReporter.Instance.SyncTicks
};
if (this.self.IsMaster)
{
PvpEvent.SendStopMove(SerializeHelper.Serialize <StopMove>(data));
}
}
this.curMoveState = EMoveState.MoveState_Idle;
}
protected override void OnSendStart()
{
HighEffInfo highEffInfo = new HighEffInfo();
if (this.targetUnits != null)
{
highEffInfo.unitIds = new List <short>();
for (int i = 0; i < this.targetUnits.Count; i++)
{
if (this.targetUnits[i] != null)
{
highEffInfo.unitIds.Add((short)this.targetUnits[i].unique_id);
}
}
}
highEffInfo.ownerUnitId = ((!(this.owner != null)) ? 0 : this.owner.unique_id);
highEffInfo.casterUnitId = ((!(base.unit != null)) ? 0 : base.unit.unique_id);
highEffInfo.rotatoY = this.rotateY;
highEffInfo.highEffId = this.data.higheffId;
highEffInfo.skillId = this.skillId;
if (this.skillPosition.HasValue)
{
highEffInfo.skillPosition = MoveController.Vector3ToSVector3(this.skillPosition.Value);
}
else
{
highEffInfo.skillPosition = MoveController.Vector3ToSVector3(Vector3.zero);
}
PvpEvent.SendDoHighEffEvent(highEffInfo);
}
protected override void OnSendStart()
{
PvpEvent.SendDoBuffEvent(new BuffInfo
{
unitId = base.unit.unique_id,
buffId = this.buffId
});
}
protected override void OnSendStart()
{
PvpEvent.SendRemoveHightEvent(new RemoveHighEffInfo
{
unitId = base.unit.unique_id,
highEffId = this.higheffId
});
}
protected override void OnSendStart()
{
PvpEvent.SendAddBuffEvent(new BuffInfo
{
unitId = this.targetUnit.unique_id,
casterUnitId = (!(base.unit != null)) ? 0 : base.unit.unique_id,
buffId = this.buffId
});
}
private void JITuiEnd()
{
if (Singleton <PvpManager> .Instance.IsInPvp && base.unit.isPlayer)
{
PvpEvent.SendFlashTo(base.unit.unique_id, base.unit.trans.position);
}
Singleton <TriggerManager> .Instance.SendUnitStateEvent(UnitEvent.UnitUnderGroud, base.unit, null, null);
this.Destroy();
}
protected override void OnSendStart()
{
PvpEvent.SendRemoveBuffEvent(new BuffInfo
{
unitId = this.targetUnit.unique_id,
casterUnitId = (!(base.unit != null)) ? 0 : base.unit.unique_id,
buffId = this.buffId,
reduce_layers = this.reduce_layers
});
}
protected override void OnSendStart()
{
if (this.skillData.end_actions != null)
{
PvpEvent.SendEndSkillEvent(new EndSkillInfo
{
unitId = base.unit.unique_id,
skillId = this.skillKey.SkillID
});
}
}
private void Update()
{
if (this.finishFlag)
{
return;
}
HeroExtraInRoom heroExtraByUserId = Singleton <PvpManager> .Instance.RoomInfo.GetHeroExtraByUserId(this.MemInfo.newUid);
if (heroExtraByUserId != null && this.targetProgress < heroExtraByUserId.LoadProgress)
{
this.targetProgress = heroExtraByUserId.LoadProgress;
}
if (this.displayProgress != 100)
{
if (this.displayProgress < this.targetProgress)
{
if (this.targetProgress > 100)
{
this.displayProgress = 100;
}
else if (this.targetProgress == 100)
{
this.displayProgress = Math.Min(100, this.displayProgress + 10);
}
else
{
this.displayProgress = Math.Min(this.targetProgress, this.displayProgress + 1);
}
this.RefreshUI_progress();
if (this.isMainPlayer)
{
while (this.qKeyPoint.Count > 0)
{
int num = this.qKeyPoint.Peek();
if (this.displayProgress < num)
{
break;
}
Debug.Log("Self send progress:" + num);
PvpEvent.SendLoadingProcessEvent((byte)this.qKeyPoint.Dequeue());
}
}
}
}
else
{
this.finishFlag = true;
if (this.OnLoadFinish != null)
{
this.OnLoadFinish(this);
}
}
}
protected void SendUseSkill(string skillID, Units target, Vector3 targetPos, bool isCrazyMode = true)
{
UseSkillInfo info = new UseSkillInfo
{
unitId = this.self.unique_id,
skillId = skillID,
targetUnit = (!(target != null)) ? 0 : target.unique_id,
targetPosition = SVector3.Build(targetPos.x, targetPos.y, targetPos.z),
targetRotate = this.self.transform.eulerAngles.y,
controlMode = (!isCrazyMode) ? 1 : 0
};
PvpEvent.SendUseSkill(info);
}
private void SendMoveToTarget(int targetId, Vector3 targetPos, float stopDistance)
{
if ((this.self.isPlayer || (this.self.MirrorState && this.self.ParentUnit.isPlayer)) && Singleton <PvpManager> .Instance.IsInPvp && GameManager.IsPlaying())
{
MoveToTarget data = new MoveToTarget
{
unitId = this.self.unique_id,
pos = MoveController.Vector3ToSVector3(this.self.transform.position),
targetId = targetId,
targetPos = MoveController.Vector3ToSVector3(targetPos),
stopDis = stopDistance
};
PvpEvent.SendMoveToTarget(SerializeHelper.Serialize <MoveToTarget>(data));
}
}
private bool DoExtraActionFirst(string skillID)
{
if (this.self.IsSkillCanTriggerBornPowerObj(skillID))
{
if (Singleton <PvpManager> .Instance.IsInPvp)
{
PvpEvent.SendDoSkillEvent(this.self.unique_id, skillID);
}
else if (this.self.skillManager != null)
{
this.self.skillManager.TriggerBornPowerObj(skillID, true);
}
return(false);
}
return(true);
}
public void SendMoveToPos(Vector3 targetPoint, float stop_distance)
{
MoveToPos data = new MoveToPos
{
unitId = this.self.unique_id,
pos = new SVector3
{
x = targetPoint.x,
y = targetPoint.y,
z = targetPoint.z
}
};
if (this.self.isPlayer || (this.self.MirrorState && this.self.ParentUnit.isPlayer))
{
PvpEvent.SendMoveToPos(SerializeHelper.Serialize <MoveToPos>(data));
}
this.lastSendTartgetPoint = targetPoint;
}
protected override void OnSendStart()
{
HighEffInfo highEffInfo = new HighEffInfo();
if (this.targetUnits != null)
{
highEffInfo.unitIds = new List <short>();
for (int i = 0; i < this.targetUnits.Count; i++)
{
if (this.targetUnits[i] != null)
{
highEffInfo.unitIds.Add((short)this.targetUnits[i].unique_id);
}
}
}
highEffInfo.casterUnitId = ((!(base.unit != null)) ? 0 : base.unit.unique_id);
highEffInfo.highEffId = this.higheffId;
highEffInfo.skillId = this.skillId;
highEffInfo.skillPosition = MoveController.Vector3ToSVector3(this.skillPosition);
PvpEvent.SendAddHighEffEvent(highEffInfo);
}
protected override void OnSendStart()
{
if (Singleton <PvpManager> .Instance.IsInPvp && PvpServerStartSkillHeroList.IsStartByServer(base.unit.npc_id))
{
return;
}
HitSkillInfo hitSkillInfo = new HitSkillInfo();
hitSkillInfo.unitId = base.unit.unique_id;
hitSkillInfo.skillId = this.skillKey.SkillID;
if (this.targetUnits != null)
{
hitSkillInfo.targetIds = new List <short>();
for (int i = 0; i < this.targetUnits.Count; i++)
{
if (this.targetUnits[i] != null)
{
hitSkillInfo.targetIds.Add((short)this.targetUnits[i].unique_id);
}
}
}
PvpEvent.SendHitSkillEvent(hitSkillInfo);
}
public void Conjure_Impl(string skillId, Units target, Vector3?targetPos, bool isPvp = false)
{
Skill skillById = this.self.getSkillById(skillId);
if (SkillUtility.IsBurnUnitSkill(skillById) && targetPos.HasValue)
{
Units touchUnit = ManualControlTarget.GetTouchUnit(targetPos.Value);
if (touchUnit != null && (touchUnit.GetType() == typeof(Tower) || touchUnit.GetType() == typeof(Home)))
{
base.OnSkillFailedBeforeStart(skillById);
ClientLogger.Warn(string.Concat(new object[]
{
"不能摆蘑菇在这里",
touchUnit,
" ",
targetPos.Value
}));
return;
}
}
if (this.self.CanSkill || skillById.CheckSkillCanUseSpecial)
{
if (target == null && !targetPos.HasValue)
{
target = this.self.GetAttackTarget();
}
skillById.attackTarget = target;
skillById.attackPosition = targetPos;
if (skillById.CheckCondition() && skillById.CheckTargets())
{
if (isPvp)
{
UseSkillInfo useSkillInfo = new UseSkillInfo
{
unitId = this.self.unique_id,
skillId = skillById.skillMainId,
targetUnit = (!(skillById.attackTarget != null)) ? 0 : skillById.attackTarget.unique_id,
targetPosition = (!skillById.attackPosition.HasValue) ? null : MoveController.Vector3ToSVector3(skillById.attackPosition.Value),
targetRotate = this.self.transform.eulerAngles.y
};
PvpEvent.SendUseSkill(useSkillInfo);
this.sendUseSkills[skillId] = true;
this.sendUseSkillTicks[skillId] = DateTime.Now.Ticks;
this.self.moveController.clearContinueMovingTarget();
if (GlobalSettings.Instance.ClientGoAhead)
{
List <Units> list = new List <Units>();
if (target != null)
{
list.Add(target);
}
ActionManager.ReadySkill(new SkillDataKey(useSkillInfo.skillId, skillById.skillLevel, 0), this.self, list, skillById.attackPosition, skillById, false);
}
}
else
{
this.self.InterruptAction(SkillInterruptType.Initiative);
skillById.OnSkillStartCallback = new Callback <Skill>(base.OnSkillStart);
skillById.OnSkillEndCallback = new Callback <Skill>(base.OnSkillEnd);
skillById.OnSkillFailedBeforeStartCallback = new Callback <Skill>(base.OnSkillFailedBeforeStart);
skillById.Start();
base.currSkill = skillById;
}
}
else
{
base.OnSkillFailedBeforeStart(skillById);
}
}
}
public void ComboAttack_Impl(int index, Units target, bool isPvp = false)
{
Skill attackByIndex = this.self.getAttackByIndex(index);
if (this.self.CanAttack && !this.isComboAttack)
{
if (attackByIndex == null)
{
base.OnAttackFailedBeforeStart(null);
return;
}
this.isComboAttack = true;
if (target == null)
{
target = this.self.GetAttackTarget();
}
attackByIndex.attackTarget = target;
if (attackByIndex.CheckCondition() && attackByIndex.CheckTargets())
{
if (!base.IsCurAttackRunnning() && this.self.CanAttack)
{
if (isPvp)
{
UseSkillInfo useSkillInfo = new UseSkillInfo
{
unitId = this.self.unique_id,
skillId = attackByIndex.skillMainId,
targetUnit = (!(target != null)) ? 0 : target.unique_id,
targetPosition = (!(target != null)) ? null : MoveController.Vector3ToSVector3(target.transform.position),
targetRotate = this.self.transform.eulerAngles.y
};
PvpEvent.SendUseSkill(useSkillInfo);
this.sendUseSkills[attackByIndex.skillMainId] = true;
this.sendUseSkillTicks[attackByIndex.skillMainId] = DateTime.Now.Ticks;
this.self.moveController.clearContinueMovingTarget();
if (GlobalSettings.Instance.ClientGoAhead)
{
List <Units> list = new List <Units>();
if (target != null)
{
list.Add(target);
}
ActionManager.ReadySkill(new SkillDataKey(useSkillInfo.skillId, attackByIndex.skillLevel, 0), this.self, list, null, attackByIndex, false);
}
}
else
{
attackByIndex.Start();
attackByIndex.OnSkillStartCallback = new Callback <Skill>(base.OnAttackStart);
attackByIndex.OnSkillEndCallback = new Callback <Skill>(base.OnAttackEnd);
attackByIndex.OnSkillFailedBeforeStartCallback = new Callback <Skill>(base.OnAttackFailedBeforeStart);
base.CurAttack = attackByIndex;
this.self.playVoice("onNormalAttack");
this.IncComboIndex();
}
}
}
else
{
base.OnAttackFailedBeforeStart(attackByIndex);
}
this.isComboAttack = false;
}
else
{
base.OnAttackFailedBeforeStart(null);
}
}
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);
}
}
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);
}
}
protected override void OnSendStart()
{
this.jumpFontInfo.unitId = base.unit.unique_id;
PvpEvent.SendJumFontEvent(this.jumpFontInfo);
}
