private bool TryCastSkill(UserInfo user, CharacterInfo target, float powDis)
{
float dis = (float)Math.Sqrt(powDis);
int category = GetCanCastSkillId(user, dis);
if (-1 != category)
{
if (user.GetSkillStateInfo().IsSkillActivated())
{
SkillInfo curSkill = user.GetSkillStateInfo().GetCurSkillInfo();
if (null != curSkill)
{
if (TimeUtility.GetLocalMilliseconds() - curSkill.StartTime > curSkill.ConfigData.LockInputTime)
{
user.SkillController.PushSkill((SkillCategory)category, target.GetMovementStateInfo().GetPosition3D());
}
}
}
else
{
user.SkillController.PushSkill((SkillCategory)category, target.GetMovementStateInfo().GetPosition3D());
}
return(true);
}
return(false);
}
private void UpdateSkillCD(SkillNode node)
{
if (node == null)
{
return;
}
SkillNode head = GetHead(node.Category);
SkillInfo head_info = m_Owner.GetSkillStateInfo().GetSkillInfoById(head.SkillId);
if (head.SkillId == node.SkillId)
{
head_info.BeginCD();
if (node.IsAlreadyPressUp)
{
head_info.CalcuteCastTime(TimeUtility.GetLocalMilliseconds() / 1000f, head_info.SkillId);
}
}
else
{
SkillInfo node_info = m_Owner.GetSkillStateInfo().GetSkillInfoById(node.SkillId);
if (node.IsAlreadyPressUp)
{
head_info.AddCD(node_info.ConfigData.CoolDownTime);
}
else
{
head_info.AddCD(node_info.ConfigData.CoolDownTime + node_info.ConfigData.CastTime);
}
}
}
public void OnHit(long hit_count_id)
{
if (TimeUtility.GetLocalMilliseconds() < m_LastTriggerTime + TriggerCD)
{
return;
}
if (hit_count_id != m_LastHitCountId)
{
m_HitNum = 0;
}
if (m_HitNum == 0)
{
m_LastHitCountId = hit_count_id;
m_HitNum++;
}
else if (hit_count_id == m_LastHitCountId)
{
m_HitNum++;
}
if (m_HitNum >= HitCount)
{
m_LastTriggerTime = TimeUtility.GetLocalMilliseconds();
//LogSystem.Error("---hit add damage rate triggered hit_count_id={0}", hit_count_id);
}
}
private SkillNode AddNextBasicSkill(SkillCategory category)
{
float now = TimeUtility.GetLocalMilliseconds() / 1000.0f;
if (m_CurSkillNode != null && m_CurSkillNode.Category == category)
{
if (m_CurSkillNode.NextSkillNode != null && !m_CurSkillNode.NextSkillNode.IsLocked &&
now < GetWaitInputTime(m_CurSkillNode))
{
m_WaiteSkillBuffer.Add(m_CurSkillNode.NextSkillNode);
return(m_CurSkillNode.NextSkillNode);
}
}
SkillNode firstNode = null;
if (m_SkillCategoryDict.TryGetValue(category, out firstNode))
{
if (!firstNode.IsLocked)
{
m_WaiteSkillBuffer.Add(firstNode);
return(firstNode);
}
}
return(null);
}
internal void Init(int id, int objId, float moveDir)
{
m_CurTotalTime = 0;
m_Id = id;
m_LastTime = TimeUtility.GetLocalMilliseconds();
m_MoveDir = moveDir;
m_ObjId = objId;
CharacterInfo info = WorldSystem.Instance.GetCharacterById(m_ObjId);
if (null != info)
{
float curMoveDir = info.GetMovementStateInfo().GetMoveDir();
m_DeltaDir = ((moveDir + c_2PI) - curMoveDir) % c_2PI;
if (m_DeltaDir > c_PI)
{
m_DeltaDir -= c_2PI;
m_TotalTime = -m_DeltaDir * c_TimePerRadian;
}
else
{
m_TotalTime = m_DeltaDir * c_TimePerRadian;
}
}
else
{
m_TotalTime = 0;
m_DeltaDir = 0;
}
//GfxSystem.GfxLog("MoveDirController {0}, obj:{1}, moveDir:{2} deltaDir:{3} totalTime:{4} isTerminated:{5}", id, objId, moveDir, m_DeltaDir, m_TotalTime, m_IsTerminated);
}
public bool IsTriggered()
{
if (TimeUtility.GetLocalMilliseconds() < m_LastTriggerTime + RemainTime)
{
return(true);
}
return(false);
}
private bool IsTimeOut(long kill_time)
{
if (kill_time + KillInterverl < TimeUtility.GetLocalMilliseconds())
{
return(true);
}
return(false);
}
protected bool CanInput(SkillCategory next_category)
{
float now = TimeUtility.GetLocalMilliseconds() / 1000.0f;
if (now < GetLockInputTime(m_CurSkillNode, next_category))
{
return(false);
}
return(true);
}
public bool OnKill(long hit_count_id)
{
if (CanTrigger(hit_count_id))
{
IsTriggered = true;
TriggerHitCountId = hit_count_id;
TriggerTime = TimeUtility.GetLocalMilliseconds();
return(true);
}
return(false);
}
public void AddKillCount(CharacterInfo character)
{
for (int i = KillsInfo.Count - 1; i >= 0; i--)
{
if (IsTimeOut(KillsInfo[i]))
{
KillsInfo.RemoveAt(i);
}
}
KillsInfo.Add(TimeUtility.GetLocalMilliseconds());
}
internal void Tick()
{
#if !USE_DISK_LOG
long curTime = TimeUtility.GetLocalMilliseconds();
if (m_LastFlushTime + 10000 < curTime)
{
m_LastFlushTime = curTime;
RequestFlush();
}
#endif
}
public override bool IsSkillCanBreak(SkillNode node, int breaktype, out bool isinterrupt, out string skillmessage)
{
isinterrupt = false;
skillmessage = "";
SkillInfo cur_skill = GetSkillInfoByNode(node);
if (cur_skill == null)
{
return(true);
}
return(cur_skill.CanBreak(breaktype, TimeUtility.GetLocalMilliseconds(), out isinterrupt, out skillmessage));
}
internal void Tick()
{
long time = TimeUtility.GetLocalMilliseconds();
int ct = m_StoryLogicInfos.Count;
for (int ix = ct - 1; ix >= 0; --ix)
{
ScriptInstanceInfo info = m_StoryLogicInfos[ix];
info.m_StoryInstance.Tick(time);
if (info.m_StoryInstance.IsTerminated)
{
RecycleStorylInstance(info);
m_StoryLogicInfos.RemoveAt(ix);
}
}
}
private void UpdateSkillNodeCD()
{
if (m_CurSkillNode != null && !m_CurSkillNode.IsCDChecked)
{
if (m_CurSkillNode.NextSkillNode == null)
{
BeginSkillCategoryCD(m_CurSkillNode.Category);
m_CurSkillNode.IsCDChecked = true;
}
else if (GetWaitInputTime(m_CurSkillNode) < TimeUtility.GetLocalMilliseconds() / 1000.0f)
{
BeginSkillCategoryCD(m_CurSkillNode.Category);
m_CurSkillNode.IsCDChecked = true;
}
}
}
public override float GetSkillCD(SkillNode node)
{
if (node == null)
{
return(0);
}
SkillNode head = GetHead(node.Category);
if (head == null)
{
return(0);
}
SkillInfo head_info = m_Owner.GetSkillStateInfo().GetSkillInfoById(head.SkillId);
return(head_info.GetCD(TimeUtility.GetLocalMilliseconds() / 1000.0f));
}
public override bool IsSkillInCD(SkillNode node)
{
if (node == null)
{
return(false);
}
SkillNode head = GetHead(node.Category);
if (node.SkillId != head.SkillId)
{
return(false);
}
SkillInfo head_info = m_Owner.GetSkillStateInfo().GetSkillInfoById(head.SkillId);
return(head_info.IsInCd(TimeUtility.GetLocalMilliseconds() / 1000.0f));
}
protected override void OnTick()
{
//这里是在逻辑线程执行的tick，渲染线程的在GameControler.cs:TickGame里。
try
{
TimeUtility.SampleClientTick();
long curTime = TimeUtility.GetLocalMilliseconds();
if (m_LastLogTime + 10000 < curTime)
{
m_LastLogTime = curTime;
#if DEBUG
if (WorldSystem.Instance.IsPvpScene() || WorldSystem.Instance.IsMultiPveScene())
{
GfxSystem.GfxLog("AverageRoundtripTime:{0}", TimeUtility.AverageRoundtripTime);
}
if (this.CurActionNum > 10)
{
GfxSystem.GfxLog("LogicThread.Tick actionNum {0}", this.CurActionNum);
}
DebugPoolCount((string msg) =>
{
GfxSystem.GfxLog("LogicActionQueue {0}", msg);
});
#endif
ClearPool(1024);
}
if (!GameControler.IsPaused)
{
NetworkSystem.Instance.Tick();
LobbyNetworkSystem.Instance.Tick();
PlayerControl.Instance.Tick();
WorldSystem.Instance.Tick();
ScriptManager.Instance.Tick(false);
}
GameControler.LogicLoggerInstance.Tick();
}
catch (Exception ex)
{
LogSystem.Error("GameLogicThread.Tick throw Exception:{0}\n{1}", ex.Message, ex.StackTrace);
}
}
private void OnSkillStart(SkillNode node)
{
HideSkillTip(SkillCategory.kNone);
m_LastSkillNode = m_CurSkillNode;
m_CurSkillNode = node;
m_CurSkillNode.StartTime = TimeUtility.GetLocalMilliseconds() / 1000.0f;
m_CurSkillNode.IsCDChecked = false;
//m_CurSkillNode.IsAlreadyPressUp = false;
m_WaiteSkillBuffer.RemoveAt(m_WaiteSkillBuffer.Count - 1);
List <SkillNode> new_buffer_element = new List <SkillNode>();
new_buffer_element.AddRange(m_WaiteSkillBuffer);
m_WaiteSkillBuffer.Clear();
if (m_CurSkillNode.NextSkillNode != null)
{
if (new_buffer_element.Count >= 1)
{
SkillNode last = new_buffer_element[new_buffer_element.Count - 1];
if (m_CurSkillNode != null && last != null &&
last.Category == m_CurSkillNode.Category)
{
PushSkill(last.Category, Vector3.Zero);
new_buffer_element.Clear();
}
}
}
if (m_LastSkillNode != null && m_LastSkillNode.Category != SkillCategory.kAttack &&
m_LastSkillNode.Category != m_CurSkillNode.Category)
{
if (!m_LastSkillNode.IsCDChecked)
{
BeginSkillCategoryCD(m_LastSkillNode.Category);
m_LastSkillNode.IsCDChecked = true;
}
}
if (null != m_SkillStartHandler)
{
m_SkillStartHandler();
}
}
public override void Adjust()
{
CharacterInfo info = WorldSystem.Instance.GetCharacterById(m_ObjId);
if (null != info)
{
float curTime = TimeUtility.GetLocalMilliseconds();
float delta = curTime - m_LastTime;
m_LastTime = curTime;
m_CurTotalTime += delta;
float moveDir = info.GetMovementStateInfo().GetMoveDir();
if (m_CurTotalTime >= m_TotalTime || Math.Abs(moveDir - m_MoveDir) <= 0.1f)
{
info.GetMovementStateInfo().SetMoveDir(m_MoveDir);
//GfxSystem.GfxLog("MoveDir adjust {0}", m_MoveDir);
m_IsTerminated = true;
}
else
{
float offset = c_PI - (m_MoveDir + c_2PI - moveDir) % c_2PI;
if (offset * m_DeltaDir <= 0)
{
info.GetMovementStateInfo().SetMoveDir(m_MoveDir);
//GfxSystem.GfxLog("MoveDir adjust {0}", m_MoveDir);
m_IsTerminated = true;
}
else
{
float newMoveDir = (moveDir + c_2PI + delta * m_DeltaDir / m_TotalTime) % c_2PI;
info.GetMovementStateInfo().SetMoveDir(newMoveDir);
//GfxSystem.GfxLog("MoveDirController {0}, obj:{1}, moveDir:{2}->{3}, delta:{4} totalTime:{5} deltaDir:{6} targetDir:{7}", m_Id, m_ObjId, moveDir, newMoveDir, delta, m_TotalTime, m_DeltaDir, m_MoveDir);
}
}
}
else
{
m_IsTerminated = true;
}
}
public void OnHit(long hit_count_id)
{
if (IsTriggered && TriggerTime + RemainTimeMS < TimeUtility.GetLocalMilliseconds())
{
Refresh();
return;
}
if (IsTriggered && hit_count_id != TriggerHitCountId)
{
if (!IsAddCriticalHitRecord)
{
AddCriticalHitCountId = hit_count_id;
IsAddCriticalHitRecord = true;
}
else if (hit_count_id != AddCriticalHitCountId)
{
Refresh();
}
}
}
private SkillNode AddQESkillNode(SkillCategory category)
{
float now = TimeUtility.GetLocalMilliseconds() / 1000.0f;
if (m_CurSkillNode == null)
{
return(null);
}
SkillNode parent = m_CurSkillNode;
bool isHaveWaiteNode = false;
if (m_WaiteSkillBuffer.Count > 0)
{
parent = m_WaiteSkillBuffer[m_WaiteSkillBuffer.Count - 1];
isHaveWaiteNode = true;
}
if (parent == null)
{
return(null);
}
if (isHaveWaiteNode || now < GetWaitInputTime(m_CurSkillNode))
{
SkillNode target = null;
if (category == SkillCategory.kSkillQ)
{
target = parent.SkillQ;
}
if (category == SkillCategory.kSkillE)
{
target = parent.SkillE;
}
if (target != null && !target.IsLocked)
{
m_WaiteSkillBuffer.Add(target);
return(target);
}
}
return(null);
}
public override bool StartSkill(SkillNode node)
{
if (WorldSystem.Instance.IsPvpScene() || WorldSystem.Instance.IsMultiPveScene())
{
if (m_Owner.GetId() == WorldSystem.Instance.PlayerSelfId || m_Owner.OwnerId == WorldSystem.Instance.PlayerSelfId)
{
Network.NetworkSystem.Instance.SyncPlayerSkill(m_Owner, node.SkillId);
}
}
else
{
if (!MakeSkillCost(node))
{
return(false);
}
}
m_Owner.ResetCross2StandRunTime();
m_Owner.GetSkillStateInfo().SetCurSkillInfo(node.SkillId);
SkillInfo cur_skill = m_Owner.GetSkillStateInfo().GetCurSkillInfo();
if (null == cur_skill)
{
LogSystem.Error("----------SkillError: {0} set cur skill {1} failed! it's not exist", m_Owner.GetId(), node.SkillId);
return(false);
}
cur_skill.IsSkillActivated = true;
cur_skill.IsInterrupted = false;
cur_skill.StartTime = TimeUtility.GetLocalMilliseconds() / 1000.0f;
UpdateSkillCD(node);
//LogSystem.Debug("---start skill at {0}--{1}", cur_skill.SkillId, cur_skill.StartTime);
CharacterView view = EntityManager.Instance.GetCharacterViewById(m_Owner.GetId());
if (view != null)
{
GfxSystem.QueueGfxAction(m_GfxSkillSystem.StartSkill, view.Actor, node.SkillId, m_Owner.GetMovementStateInfo().GetWantFaceDir());
}
SimulateStartSkill(m_Owner, node.SkillId);
return(true);
}
public override bool ForceStartSkill(int skillid)
{
m_Owner.GetSkillStateInfo().SetCurSkillInfo(skillid);
SkillInfo cur_skill = m_Owner.GetSkillStateInfo().GetCurSkillInfo();
if (null == cur_skill)
{
LogSystem.Error("----------ForceStartSkillError: {0} set cur skill {1} failed! it's not exist", m_Owner.GetId(), skillid);
return(false);
}
if (cur_skill.SkillId != skillid)
{
LogSystem.Debug("----------ForceStartSkillError: {0} set cur skill {1} failed! it's {2}", m_Owner.GetId(), skillid, cur_skill.SkillId);
return(false);
}
if (null != cur_skill)
{
cur_skill.IsSkillActivated = true;
cur_skill.IsInterrupted = false;
cur_skill.StartTime = TimeUtility.GetLocalMilliseconds() / 1000.0f;
//LogSystem.Debug("---force start skill at {0}--{1}", cur_skill.SkillId, cur_skill.StartTime);
CharacterView view = EntityManager.Instance.GetCharacterViewById(m_Owner.GetId());
if (view != null)
{
GfxSystem.QueueGfxAction(m_GfxSkillSystem.StartSkill, view.Actor, skillid, m_Owner.GetMovementStateInfo().GetWantFaceDir());
}
}
else
{
List <SkillInfo> skills = m_Owner.GetSkillStateInfo().GetAllSkill();
LogSystem.Error("Can't find skill {0}, obj has {1} skills", skillid, skills.Count);
foreach (SkillInfo info in skills)
{
LogSystem.Error("\tskill {0}", info.SkillId);
}
}
SimulateStartSkill(m_Owner, skillid);
return(true);
}
public override bool BreakCurSkill(int breaktype, SkillCategory category)
{
if (category == m_CurSkillNode.Category)
{
bool result = StopSkill(m_CurSkillNode, breaktype);
if (!result)
{
if (!m_CurSkillNode.IsAlreadyPressUp)
{
m_CurSkillNode.IsAlreadyPressUp = true;
SkillNode head = GetHead(m_CurSkillNode.Category);
SkillInfo skillInfo = m_Owner.GetSkillStateInfo().GetSkillInfoById(head.SkillId);
if (skillInfo != null)
{
skillInfo.CalcuteCastTime(TimeUtility.GetLocalMilliseconds() / 1000f, m_CurSkillNode.SkillId);
}
}
else
{
SkillNode skillnode = m_WaiteSkillBuffer.Find(s => s.Category == category && s.IsAlreadyPressUp == false);
if (skillnode != null)
{
skillnode.IsAlreadyPressUp = true;
}
}
}
return(result);
}
else
{
SkillNode skillnode = m_WaiteSkillBuffer.Find(s => s.Category == category && s.IsAlreadyPressUp == false);
if (skillnode != null)
{
skillnode.IsAlreadyPressUp = true;
}
}
return(false);
}
internal void Log(string format, params object[] args)
{
if (m_LogStream == null)
{
return;
}
string msg = string.Format(format, args);
#if USE_DISK_LOG
if (m_LogStream != null)
{
m_LogStream.WriteLine(msg);
m_LogStream.Flush();
}
#else
m_LogQueue.Enqueue(msg);
if (!m_IsInRequestFlush && m_LogQueue.Count >= c_FlushCount)
{
m_LastFlushTime = TimeUtility.GetLocalMilliseconds();
RequestFlush();
}
#endif
}
public void Add(string operationKey)
{
long startTime = TimeUtility.GetLocalMilliseconds();
m_OperationTimeDict.AddOrUpdate(operationKey, startTime, startTime);
}
public void OnGfxHitTarget(int id, int impactId, int targetId, int hitCount,
int skillId, int duration, float x,
float y, float z, float dir, long hit_count_id)
{
CharacterInfo sender = WorldSystem.Instance.GetCharacterById(id);
CharacterInfo target = WorldSystem.Instance.GetCharacterById(targetId);
UserInfo playerSelf = WorldSystem.Instance.GetPlayerSelf();
bool hitCountChanged = false;
bool playerHitCountChange = false;
long curTime = TimeUtility.GetLocalMilliseconds();
UpdateHitTalent(sender, hit_count_id);
// 攻击
if (hitCount > 0)
{
CombatStatisticInfo senderCombatInfo = sender.GetCombatStatisticInfo();
int last_count = senderCombatInfo.MultiHitCount;
if (IsImpactHaveDamage(impactId))
{
hitCountChanged = senderCombatInfo.UpdateMultiHitCount(hit_count_id, hitCount, curTime);
}
if (id == WorldSystem.Instance.PlayerSelfId && null != playerSelf)
{
if (senderCombatInfo.MultiHitCount >= 1 && last_count != senderCombatInfo.MultiHitCount)
{
GfxSystem.PublishGfxEvent("ge_hitcount", "ui", senderCombatInfo.MultiHitCount);
playerHitCountChange = hitCountChanged;
}
}
CombatStatisticInfo targetCombatInfo = target.GetCombatStatisticInfo();
targetCombatInfo.HitCount += hitCount;
if (targetId == WorldSystem.Instance.PlayerSelfId && null != playerSelf)
{
if (WorldSystem.Instance.IsELiteScene())
{
RoleInfo roleInfo = LobbyClient.Instance.CurrentRole;
SceneResource curScene = WorldSystem.Instance.GetCurScene();
if (null != roleInfo && null != curScene && roleInfo.GetSceneInfo(WorldSystem.Instance.GetCurSceneId()) == 2)
{ //当前在挑战3星通关
GfxSystem.PublishGfxEvent("ge_pve_fightinfo", "ui", 0, targetCombatInfo.HitCount, curScene.SceneConfig.m_CompletedHitCount, 0);
}
playerHitCountChange = true;
}
}
}
if (playerHitCountChange && null != playerSelf && (WorldSystem.Instance.IsPvpScene() || WorldSystem.Instance.IsMultiPveScene()))
{
CombatStatisticInfo combatInfo = playerSelf.GetCombatStatisticInfo();
ArkCrossEngineMessage.Msg_CR_HitCountChanged msg = new ArkCrossEngineMessage.Msg_CR_HitCountChanged();
msg.max_multi_hit_count = combatInfo.MaxMultiHitCount;
msg.hit_count = combatInfo.HitCount;
Network.NetworkSystem.Instance.SendMessage(msg);
}
if (null != sender && null != target)
{
int hit_count = 0;
hit_count = sender.GetCombatStatisticInfo().MultiHitCount;
OnGfxStartImpact(sender.GetId(), impactId, target.GetId(), skillId, duration, new Vector3(x, y, z), dir,
hit_count);
}
}
