Beispiel #1
0
        //用于上层逻辑检查通过后调用
        public void StartSkill(int actorId, int skillId, float facedir)
        {
            GameObject obj = LogicSystem.GetGameObject(actorId);

            if (null != obj)
            {
                SkillLogicInfo logicInfo = m_SkillLogicInfos.Find(info => info.Sender == obj && info.SkillId == skillId);
                if (logicInfo != null)
                {
                    return;
                }
                ChangeDir(obj, facedir);
                SkillInstanceInfo inst = NewSkillInstance(skillId);
                if (null != inst)
                {
                    m_SkillLogicInfos.Add(new SkillLogicInfo(obj, inst));
                }
                else
                {
                    LogicSystem.NotifyGfxStopSkill(obj, skillId);
                    return;
                }

                logicInfo = m_SkillLogicInfos.Find(info => info.Sender == obj && info.SkillId == skillId);
                if (null != logicInfo)
                {
                    if (OnGfxShillStart != null)
                    {
                        OnGfxShillStart(obj, skillId);
                    }
                    LogicSystem.NotifyGfxAnimationStart(obj, true);
                    logicInfo.SkillInst.Start(logicInfo.Sender);
                }
            }
        }
        public void StopAllSkillWithGameObject(GameObject obj, bool isinterrupt, bool includeImpact, bool includeBuff)
        {
            if (null == obj)
            {
                return;
            }
            int count = m_SkillLogicInfos.Count;

            for (int index = count - 1; index >= 0; --index)
            {
                SkillLogicInfo info = m_SkillLogicInfos[index];
                if (info != null)
                {
                    if (info.GfxObj == obj)
                    {
                        if (!includeImpact && info.Sender.ConfigData.type == (int)SkillOrImpactType.Impact)
                        {
                            continue;
                        }
                        if (!includeBuff && info.Sender.ConfigData.type == (int)SkillOrImpactType.Buff)
                        {
                            continue;
                        }
                        if (isinterrupt)
                        {
                            info.SkillInst.OnInterrupt(info.Sender);
                        }
                        info.SkillInst.OnSkillStop(info.Sender);
                        StopSkillInstance(info, isinterrupt);
                        m_SkillLogicInfos.RemoveAt(index);
                    }
                }
            }
        }
        public void PauseAllSkill(int actorId, bool pause)
        {
            GameObject obj = EntityController.Instance.GetGameObject(actorId);

            if (null == obj)
            {
                return;
            }
            int count = m_SkillLogicInfos.Count;

            for (int index = count - 1; index >= 0; --index)
            {
                SkillLogicInfo info = m_SkillLogicInfos[index];
                if (info != null)
                {
                    if (info.GfxObj == obj)
                    {
                        info.IsPaused = pause;

                        Trigers.EffectManager effectMgr = info.SkillInst.CustomDatas.GetData <Trigers.EffectManager>();
                        if (null != effectMgr)
                        {
                            effectMgr.PauseEffects(pause);
                        }
                    }
                }
            }
            EntityController.Instance.PauseSkillAnimation(actorId, pause);
        }
Beispiel #4
0
        public void StopSkill(int actorId, bool isinterrupt)
        {
            GameObject obj = LogicSystem.GetGameObject(actorId);

            if (null == obj)
            {
                return;
            }
            int count = m_SkillLogicInfos.Count;

            for (int index = count - 1; index >= 0; --index)
            {
                SkillLogicInfo info = m_SkillLogicInfos[index];
                if (info != null)
                {
                    if (info.Sender == obj)
                    {
                        if (isinterrupt)
                        {
                            info.SkillInst.OnInterrupt(obj, 0);
                        }
                        else
                        {
                            info.SkillInst.OnSkillStop(obj, 0);
                        }
                        StopSkillInstance(info, isinterrupt);
                        m_SkillLogicInfos.RemoveAt(index);
                    }
                }
            }
        }
 internal void Tick()
 {
     try {
         int  ct      = m_SkillLogicInfos.Count;
         long curTime = TimeUtility.GetLocalMicroseconds();
         if (m_LastTickTime <= 0)
         {
             m_LastTickTime = curTime;
             return;
         }
         long delta = curTime - m_LastTickTime;
         m_LastTickTime = curTime;
         for (int ix = ct - 1; ix >= 0; --ix)
         {
             SkillLogicInfo info  = m_SkillLogicInfos[ix];
             bool           exist = m_Scene.EntityController.ExistGameObject(info.ActorId);
             if (exist)
             {
                 info.SkillInst.Tick(info.Sender, delta);
             }
             if (!exist || info.SkillInst.IsFinished)
             {
                 if (!exist)
                 {
                     info.SkillInst.OnSkillStop(info.Sender);
                 }
                 StopSkillInstance(info);
                 m_SkillLogicInfos.RemoveAt(ix);
             }
         }
     } finally {
     }
 }
 public void Tick()
 {
     try {
         UnityEngine.Profiling.Profiler.BeginSample("GfxSkillSystem.Tick");
         int  ct    = m_SkillLogicInfos.Count;
         long delta = (long)(Time.deltaTime * 1000000);
         for (int ix = ct - 1; ix >= 0; --ix)
         {
             SkillLogicInfo info  = m_SkillLogicInfos[ix];
             bool           exist = EntityController.Instance.ExistGameObject(info.GfxObj);
             if (exist && !info.IsPaused)
             {
                 info.SkillInst.Tick(info.Sender, delta);
             }
             if (!exist || info.SkillInst.IsFinished)
             {
                 if (!exist)
                 {
                     info.SkillInst.OnSkillStop(info.Sender);
                 }
                 StopSkillInstance(info);
                 m_SkillLogicInfos.RemoveAt(ix);
             }
         }
     } finally {
         UnityEngine.Profiling.Profiler.EndSample();
     }
 }
Beispiel #7
0
        internal void StopSkill(int objId)
        {
            CharacterInfo obj = CurScene.SceneContext.GetCharacterInfoById(objId);

            if (null == obj)
            {
                return;
            }
            int count = m_SkillLogicInfos.Count;

            for (int index = count - 1; index >= 0; --index)
            {
                SkillLogicInfo info = m_SkillLogicInfos[index];
                if (info.SenderId == objId)
                {
                    //DashFire.LogSystem.Warn("Skill {0} finished (stop skill).", info.SkillId);

                    if (info.SkillInst.IsControlMove)
                    {
                        obj.GetMovementStateInfo().IsSkillMoving = false;
                        info.SkillInst.IsControlMove = false;
                    }
                    SkillInfo skillInfo = obj.GetSkillStateInfo().GetSkillInfoById(info.SkillId);
                    if (null != skillInfo)
                    {
                        skillInfo.IsSkillActivated = false;
                    }
                    RecycleSkillInstance(info.Info);
                    m_SkillLogicInfos.RemoveAt(index);
                    info.SkillInst.IsInterrupted = true;
                }
            }
        }
        private void StopSkillInstance(SkillLogicInfo info, bool isInterrupt)
        {
            if (isInterrupt)
            {
            }

            GameFramework.LogSystem.Debug("Skill {0} finished.", info.SkillId);
            m_Scene.EntityController.DeactivateSkill(info.ActorId, info.SkillId, info.Sender.Seq);
            RecycleSkillInstance(info.Info);
        }
        public SkillInstance FindActiveSkillInstance(int actorId, int skillId, int seq, out GfxSkillSenderInfo sender)
        {
            SkillLogicInfo logicInfo = m_SkillLogicInfos.Find(info => info.ActorId == actorId && info.SkillId == skillId && info.Seq == seq);

            if (null != logicInfo)
            {
                sender = logicInfo.Sender;
                return(logicInfo.SkillInst);
            }
            sender = null;
            return(null);
        }
Beispiel #10
0
        internal void SendMessage(int objId, int skillId, string msgId)
        {
            CharacterInfo obj = CurScene.SceneContext.GetCharacterInfoById(objId);

            if (null != obj)
            {
                SkillLogicInfo logicInfo = m_SkillLogicInfos.Find(info => info.SenderId == objId && info.SkillId == skillId);
                if (null != logicInfo && null != logicInfo.SkillInst)
                {
                    logicInfo.SkillInst.SendMessage(msgId);
                }
            }
        }
 public void CancelSkillWithGameObject(GameObject obj, int skillId, int seq)
 {
     if (null != obj)
     {
         SkillLogicInfo logicInfo = FindSkillLogicInfo(obj, skillId, seq);
         if (null != logicInfo)
         {
             EntityController.Instance.DeactivateSkill(logicInfo.Sender, logicInfo.SkillInst);
             RecycleSkillInstance(logicInfo.Info);
             m_SkillLogicInfos.Remove(logicInfo);
         }
     }
 }
Beispiel #12
0
        public void SendMessage(int actorId, int skillId, string msgId)
        {
            GameObject obj = LogicSystem.GetGameObject(actorId);

            if (null != obj)
            {
                SkillLogicInfo logicInfo = m_SkillLogicInfos.Find(info => info.Sender == obj && info.SkillId == skillId);
                if (null != logicInfo && null != logicInfo.SkillInst)
                {
                    logicInfo.SkillInst.SendMessage(msgId);
                }
            }
        }
        internal void PauseSkill(int actorId, int skillId, int seq, bool pause)
        {
            EntityInfo obj = m_Scene.EntityController.GetGameObject(actorId);

            if (null != obj)
            {
                SkillLogicInfo logicInfo = m_SkillLogicInfos.Find(info => info.GfxObj == obj && info.SkillId == skillId && info.Seq == seq);
                if (null != logicInfo)
                {
                    logicInfo.IsPaused = pause;
                }
            }
        }
Beispiel #14
0
        internal void Reset()
        {
            m_LastTickTime = 0;
            int count = m_SkillLogicInfos.Count;

            for (int index = count - 1; index >= 0; --index)
            {
                SkillLogicInfo info = m_SkillLogicInfos[index];
                RecycleSkillInstance(info.Info);
                m_SkillLogicInfos.RemoveAt(index);
            }
            m_SkillLogicInfos.Clear();
        }
        //在技能未开始时取消技能(用于上层逻辑检查失败时)
        public void CancelSkill(int actorId, int skillId, int seq)
        {
            GameObject obj = EntityController.Instance.GetGameObject(actorId);

            if (null != obj)
            {
                SkillLogicInfo logicInfo = m_SkillLogicInfos.Find(info => info.GfxObj == obj && info.SkillId == skillId && info.Seq == seq);
                if (null != logicInfo)
                {
                    EntityController.Instance.DeactivateSkill(actorId, skillId, seq);
                    RecycleSkillInstance(logicInfo.Info);
                    m_SkillLogicInfos.Remove(logicInfo);
                }
            }
        }
        private SkillLogicInfo FindSkillLogicInfo(int objId, int skillId, int seq)
        {
            SkillLogicInfo ret = null;
            int            ct  = m_SkillLogicInfos.Count;

            for (int ix = 0; ix < ct; ++ix)
            {
                var info = m_SkillLogicInfos[ix];
                if (info.ObjId == objId && info.SkillId == skillId && info.Seq == seq)
                {
                    ret = info;
                    break;
                }
            }
            return(ret);
        }
        private SkillLogicInfo FindSkillLogicInfo(UnityEngine.GameObject obj, int skillId, int seq)
        {
            SkillLogicInfo ret = null;
            int            ct  = m_SkillLogicInfos.Count;

            for (int ix = 0; ix < ct; ++ix)
            {
                var info = m_SkillLogicInfos[ix];
                if (info.GfxObj == obj && info.SkillId == skillId && info.Seq == seq)
                {
                    ret = info;
                    break;
                }
            }
            return(ret);
        }
        private SkillLogicInfo FindSkillLogicInfoForSkillViewer(int skillId)
        {
            SkillLogicInfo ret = null;
            int            ct  = m_SkillLogicInfos.Count;

            for (int ix = 0; ix < ct; ++ix)
            {
                var info = m_SkillLogicInfos[ix];
                if (info.SkillId == skillId)
                {
                    ret = info;
                    break;
                }
            }
            return(ret);
        }
        private SkillLogicInfo FindInnerSkillLogicInfoForSkillViewer(int skillId, int innerDslSkillId, int outerDslSkillId)
        {
            SkillLogicInfo ret = null;
            int            ct  = m_SkillLogicInfos.Count;

            for (int ix = 0; ix < ct; ++ix)
            {
                var info = m_SkillLogicInfos[ix];
                if (info.SkillId == skillId && info.SkillInst.InnerDslSkillId == innerDslSkillId && info.SkillInst.OuterDslSkillId == outerDslSkillId)
                {
                    ret = info;
                    break;
                }
            }
            return(ret);
        }
        public void Reset()
        {
            int count = m_SkillLogicInfos.Count;

            for (int index = count - 1; index >= 0; --index)
            {
                SkillLogicInfo info = m_SkillLogicInfos[index];
                if (null != info)
                {
                    info.SkillInst.OnSkillStop(info.Sender);
                    StopSkillInstance(info);
                    m_SkillLogicInfos.RemoveAt(index);
                }
            }
            m_SkillLogicInfos.Clear();
        }
 public void StopSkillWithGameObject(GameObject obj, int skillId, int seq, bool isinterrupt)
 {
     if (null != obj)
     {
         SkillLogicInfo logicInfo = FindSkillLogicInfo(obj, skillId, seq);
         if (null != logicInfo)
         {
             if (isinterrupt)
             {
                 logicInfo.SkillInst.OnInterrupt(logicInfo.Sender);
             }
             logicInfo.SkillInst.OnSkillStop(logicInfo.Sender);
             StopSkillInstance(logicInfo, isinterrupt);
             m_SkillLogicInfos.Remove(logicInfo);
         }
     }
 }
        public void PauseSkillWithGameObject(GameObject obj, int skillId, int seq, bool pause)
        {
            if (null != obj)
            {
                SkillLogicInfo logicInfo = FindSkillLogicInfo(obj, skillId, seq);
                if (null != logicInfo)
                {
                    logicInfo.IsPaused = pause;

                    Trigers.EffectManager effectMgr = logicInfo.SkillInst.CustomDatas.GetData <Trigers.EffectManager>();
                    if (null != effectMgr)
                    {
                        effectMgr.PauseEffects(pause);
                    }
                    EntityController.Instance.PauseSkillAnimation(obj, pause);
                }
            }
        }
 public void SendMessageWithGameObject(GameObject obj, int skillId, int seq, string msgId, Dictionary <string, object> locals)
 {
     if (null != obj)
     {
         SkillLogicInfo logicInfo = FindSkillLogicInfo(obj, skillId, seq);
         if (null != logicInfo && null != logicInfo.SkillInst)
         {
             if (null != locals)
             {
                 foreach (KeyValuePair <string, object> pair in locals)
                 {
                     logicInfo.SkillInst.SetVariable(pair.Key, pair.Value);
                 }
             }
             logicInfo.SkillInst.SendMessage(msgId);
         }
     }
 }
Beispiel #24
0
        internal void Tick()
        {
            long time  = TimeUtility.GetServerMilliseconds();
            long delta = (time - m_LastTickTime) * 1000;

            m_LastTickTime = time;
            int ct = m_SkillLogicInfos.Count;

            for (int ix = ct - 1; ix >= 0; --ix)
            {
                SkillLogicInfo info = m_SkillLogicInfos[ix];
                CharacterInfo  obj  = CurScene.SceneContext.GetCharacterInfoById(info.SenderId);
                if (null != obj)
                {
                    info.SkillInst.Tick(obj, delta);

                    //DashFire.LogSystem.Debug("Skill {0} tick {1}.", info.SkillId, time);
                }
                if (null == obj || info.SkillInst.IsFinished)
                {
                    //DashFire.LogSystem.Warn("Skill {0} finished (time finish).", info.SkillId);

                    if (info.SkillInst.IsControlMove)
                    {
                        if (null != obj)
                        {
                            obj.GetMovementStateInfo().IsSkillMoving = false;
                        }
                        info.SkillInst.IsControlMove = false;
                    }
                    if (null != obj)
                    {
                        SkillInfo skillInfo = obj.GetSkillStateInfo().GetSkillInfoById(info.SkillId);
                        if (null != skillInfo)
                        {
                            skillInfo.IsSkillActivated = false;
                        }
                    }
                    RecycleSkillInstance(info.Info);
                    m_SkillLogicInfos.RemoveAt(ix);
                }
            }
        }
        private void StopSkillInstance(SkillLogicInfo info, bool isInterrupt)
        {
            if (isInterrupt)
            {
                Trigers.EffectManager effectMgr = info.SkillInst.CustomDatas.GetData <Trigers.EffectManager>();
                if (null != effectMgr)
                {
                    effectMgr.StopEffects();
                }
                if (info.Sender.ConfigData.type == (int)SkillOrImpactType.Skill)
                {
                    EntityController.Instance.StopSkillAnimation(info.ActorId);
                }
            }

            //GameFramework.LogSystem.Debug("Skill {0} finished.", info.SkillId);
            EntityController.Instance.DeactivateSkill(info.ActorId, info.SkillId, info.Sender.Seq);
            RecycleSkillInstance(info.Info);
        }
        public void StopSkill(int actorId, int skillId, int seq, bool isinterrupt)
        {
            GameObject obj = EntityController.Instance.GetGameObject(actorId);

            if (null != obj)
            {
                SkillLogicInfo logicInfo = m_SkillLogicInfos.Find(info => info.GfxObj == obj && info.SkillId == skillId && info.Seq == seq);
                if (null != logicInfo)
                {
                    if (isinterrupt)
                    {
                        logicInfo.SkillInst.OnInterrupt(logicInfo.Sender);
                    }
                    logicInfo.SkillInst.OnSkillStop(logicInfo.Sender);
                    StopSkillInstance(logicInfo, isinterrupt);
                    m_SkillLogicInfos.Remove(logicInfo);
                }
            }
        }
Beispiel #27
0
        public void Tick()
        {
            try
            {
                Profiler.BeginSample("GfxSkillSystem.Tick");
                int  ct    = m_SkillLogicInfos.Count;
                long delta = (long)(Time.deltaTime * 1000 * 1000);
                for (int ix = ct - 1; ix >= 0; --ix)
                {
                    SkillLogicInfo info  = m_SkillLogicInfos[ix];
                    bool           exist = LogicSystem.ExistGameObject(info.Sender);
                    if (exist)
                    {
                        info.SkillInst.Tick(info.Sender, delta);
                    }
                    if (!exist || info.SkillInst.IsFinished)
                    {
                        if (!exist)
                        {
                            info.SkillInst.OnSkillStop(info.Sender, 0);
                        }
                        StopSkillInstance(info);
                        m_SkillLogicInfos.RemoveAt(ix);
                    }
                }

                int product_count = m_SkillProducts.Count;
                for (int i = product_count - 1; i >= 0; --i)
                {
                    ISkillProduct product = m_SkillProducts[i];
                    product.Tick(delta);
                    if (product.IsStoped())
                    {
                        m_SkillProducts.RemoveAt(i);
                    }
                }
            }
            finally
            {
                Profiler.EndSample();
            }
        }
        public void SendMessage(int actorId, int skillId, int seq, string msgId, Dictionary <string, object> locals)
        {
            GameObject obj = EntityController.Instance.GetGameObject(actorId);

            if (null != obj)
            {
                SkillLogicInfo logicInfo = m_SkillLogicInfos.Find(info => info.GfxObj == obj && info.SkillId == skillId && info.Seq == seq);
                if (null != logicInfo && null != logicInfo.SkillInst)
                {
                    if (null != locals)
                    {
                        foreach (KeyValuePair <string, object> pair in locals)
                        {
                            logicInfo.SkillInst.SetVariable(pair.Key, pair.Value);
                        }
                    }
                    logicInfo.SkillInst.SendMessage(msgId);
                }
            }
        }
        public void PauseSkill(int actorId, int skillId, int seq, bool pause)
        {
            GameObject obj = EntityController.Instance.GetGameObject(actorId);

            if (null != obj)
            {
                SkillLogicInfo logicInfo = m_SkillLogicInfos.Find(info => info.GfxObj == obj && info.SkillId == skillId && info.Seq == seq);
                if (null != logicInfo)
                {
                    logicInfo.IsPaused = pause;

                    Trigers.EffectManager effectMgr = logicInfo.SkillInst.CustomDatas.GetData <Trigers.EffectManager>();
                    if (null != effectMgr)
                    {
                        effectMgr.PauseEffects(pause);
                    }
                    EntityController.Instance.PauseSkillAnimation(actorId, pause);
                }
            }
        }
Beispiel #30
0
        //在技能未开始时取消技能(用于上层逻辑检查失败时)
        public void CancelSkill(int actorId, int skillId)
        {
            GameObject obj = LogicSystem.GetGameObject(actorId);

            if (null != obj)
            {
                SkillLogicInfo logicInfo = m_SkillLogicInfos.Find(info => info.Sender == obj && info.SkillId == skillId);
                if (null != logicInfo)
                {
                    if (logicInfo.SkillInst.IsControlMove)
                    {
                        LogicSystem.NotifyGfxMoveControlFinish(obj, skillId, true);
                        logicInfo.SkillInst.IsControlMove = false;
                    }
                    LogicSystem.NotifyGfxAnimationFinish(obj, true);
                    RecycleSkillInstance(logicInfo.Info);
                    m_SkillLogicInfos.Remove(logicInfo);
                }
            }
        }
        private void StopSkillInstance(SkillLogicInfo info, bool isInterrupt)
        {
            if (isInterrupt) {
                Trigers.EffectManager effectMgr = info.SkillInst.CustomDatas.GetData<Trigers.EffectManager>();
                if (null != effectMgr) {
                    effectMgr.StopEffects();
                }
                if (info.Sender.ConfigData.type == (int)SkillOrImpactType.Skill) {
                    EntityController.Instance.StopSkillAnimation(info.ActorId);
                }
            }

            //GameFramework.LogSystem.Debug("Skill {0} finished.", info.SkillId);
            EntityController.Instance.DeactivateSkill(info.ActorId, info.SkillId, info.Sender.Seq);
            RecycleSkillInstance(info.Info);
        }
        private void StopSkillInstance(SkillLogicInfo info, bool isInterrupt)
        {
            if (isInterrupt) {
            }

            GameFramework.LogSystem.Debug("Skill {0} finished.", info.SkillId);
            m_Scene.EntityController.DeactivateSkill(info.ActorId, info.SkillId, info.Sender.Seq);
            RecycleSkillInstance(info.Info);
        }
Beispiel #33
0
 private void StopSkillInstance(SkillLogicInfo info)
 {
     StopSkillInstance(info, false);
 }
Beispiel #34
0
 private void StopSkillInstance(SkillLogicInfo info, bool isInterrupt)
 {
     //DashFire.LogSystem.Debug("Skill {0} finished.", info.SkillId);
     if (!isInterrupt)
     {
         if (info.SkillInst.IsControlMove)
         {
             //DashFire.LogicSystem.NotifyGfxMoveControlFinish(info.Sender, info.SkillId, true);
             info.SkillInst.IsControlMove = false;
         }
         //DashFire.LogicSystem.NotifyGfxAnimationFinish(info.Sender, true);
         //DashFire.LogicSystem.NotifyGfxStopSkill(info.Sender, info.SkillId);
     }
     else
     {
         if (info.SkillInst.IsControlMove)
         {
             info.SkillInst.IsControlMove = false;
         }
     }
     RecycleSkillInstance(info.Info);
 }