public void Reset()
 {
     m_state       = AccumulateOffsetState;
     m_command_crc = 0;
     m_offset      = Vector3.zero;
     if (m_task != null)
     {
         m_task.Cancel();
         RenderTask.Recycle(m_task);
         m_task = null;
     }
 }
Пример #2
0
 void RecycleRenderEffectInfo(RenderEffectInfo info, RenderEffectData config)
 {
     if (info.m_task != null)
     {
         RenderTask.Recycle(info.m_task);
         info.m_task = null;
     }
     if (info.m_go != null)
     {
         if (config == null)
         {
             config = GetRenderWorld().GetRenderEffectData(info.m_render_effect_cfgid);
         }
         info.m_go.transform.parent = null;
         UnityResourceManager.Instance.RecycleGameObject(config.m_prefab, info.m_go);
         info.m_go = null;
     }
     RecyclableObject.Recycle(info);
 }
Пример #3
0
        public void PlayRenderEffect(int render_effect_cfg_id, FixPoint play_time)
        {
            //ZZWTODO 为了精准识别每一个effect,可以考虑在逻辑端生成一个id
            RenderEffectData config = GetRenderWorld().GetRenderEffectData(render_effect_cfg_id);

            if (config == null)
            {
                return;
            }
            RenderEffectNode node;

            if (!m_nodes.TryGetValue(config.m_binding, out node))
            {
                string path;
                if (!m_binding_name_to_path.TryGetValue(config.m_binding, out path))
                {
                    return;
                }
                ModelComponent model_component = ParentObject.GetComponent(ModelComponent.ID) as ModelComponent;
                if (model_component == null)
                {
                    return;
                }
                Transform tr = model_component.GetUnityGameObject().transform.FindChild(path);
                if (tr == null)
                {
                    return;
                }
                node                      = new RenderEffectNode();
                node.m_parent_tr          = tr;
                m_nodes[config.m_binding] = node;
            }
            //RenderEffectInfo info = null;
            //for (int i = 0; i < node.m_render_effects.Count; ++i)
            //{
            //    if (node.m_render_effects[i].m_render_effect_cfgid == render_effect_cfg_id)
            //    {
            //        info = node.m_render_effects[i];
            //        break;
            //    }
            //}
            //if (info != null)
            //{
            //}
            GameObject effect_go = UnityResourceManager.Instance.CreateGameObject(config.m_prefab);

            if (effect_go == null)
            {
                return;
            }
            effect_go.transform.parent           = node.m_parent_tr;
            effect_go.transform.localPosition    = Vector3.zero;
            effect_go.transform.localScale       = Vector3.one;
            effect_go.transform.localEulerAngles = Vector3.zero;
            RenderEffectInfo info = RecyclableObject.Create <RenderEffectInfo>();

            info.m_render_effect_cfgid = render_effect_cfg_id;
            info.m_go = effect_go;
            if (play_time > FixPoint.Zero)
            {
                var task_scheduler          = GetRenderWorld().GetTaskScheduler();
                RemoveRenderEffectTask task = RenderTask.Create <RemoveRenderEffectTask>();
                task.Construct(this, render_effect_cfg_id);
                task_scheduler.Schedule(task, GetRenderWorld().CurrentTime, play_time);
                info.m_task = task;
            }
            node.m_render_effects.Add(info);
        }
        void PredictEntityMove(EntityMoveCommand cmd)
        {
            switch (cmd.m_move_type)
            {
            case EntityMoveCommand.DirectionType:
            {
                m_copy_state = NoCopy;
                bool exist = false;
                uint crc   = CalculateMoveCommandCRC(cmd);
                //LogWrapper.LogDebug("PredictEntityMove, DirectionType, time =", GetCurrentTime(), ", dir = ", cmd.m_vector.ToString(), ", crc = ", crc);
                for (int i = 0; i < m_movement_predicts.Count; ++i)
                {
                    MovementPredict predict = m_movement_predicts[i];
                    if (predict.m_command_crc == crc)
                    {
                        if (predict.m_state == MovementPredict.AccumulateOffsetState || predict.m_state == MovementPredict.FollowLogicState)
                        {
                            exist = true;
                        }
                    }
                    else if (predict.m_state == MovementPredict.AccumulateOffsetState || predict.m_state == MovementPredict.FollowLogicState)
                    {
                        predict.m_state = MovementPredict.EliminateOffsetState;
                        predict.m_task.Cancel();
                    }
                }
                if (!exist)
                {
                    Vector3 direction          = RenderWorld.Vector3FP_To_Vector3(cmd.m_vector);
                    PredictLocomotionTask task = RenderTask.Create <PredictLocomotionTask>();
                    task.Construct(this, direction, m_max_predict_time);
                    var task_scheduler = GetRenderWorld().GetTaskScheduler();
                    task_scheduler.Schedule(task, GetRenderWorld().CurrentTime, FixPoint.PrecisionFP);
                    MovementPredict predict = RecyclableObject.Create <MovementPredict>();
                    predict.m_state       = MovementPredict.AccumulateOffsetState;
                    predict.m_command_crc = crc;
                    predict.m_task        = task;
                    m_movement_predicts.Add(predict);
                    PlayMoveAnimation(direction);
                }
            }
            break;

            case EntityMoveCommand.DestinationType:
            {
                if (m_copy_state == NoCopy)
                {
                    m_copy_state = WaitCopy;
                }
                //下面这段代码和EntityMoveCommand.StopMoving差不多
                for (int i = 0; i < m_movement_predicts.Count; ++i)
                {
                    MovementPredict predict = m_movement_predicts[i];
                    if (predict.m_state == MovementPredict.AccumulateOffsetState || predict.m_state == MovementPredict.FollowLogicState)
                    {
                        predict.m_state = MovementPredict.EliminateOffsetState;
                        predict.m_task.Cancel();
                    }
                }
                MovementPredict temp = RecyclableObject.Create <MovementPredict>();
                temp.m_state = MovementPredict.CopyLogicState;
                m_movement_predicts.Add(temp);
                Vector3 direction = RenderWorld.Vector3FP_To_Vector3(cmd.m_vector) - m_model_component.GetCurrentPosition();
                PlayMoveAnimation(direction);
            }
            break;

            case EntityMoveCommand.StopMoving:
            {
                m_copy_state = NoCopy;
                for (int i = 0; i < m_movement_predicts.Count; ++i)
                {
                    MovementPredict predict = m_movement_predicts[i];
                    if (predict.m_state == MovementPredict.AccumulateOffsetState || predict.m_state == MovementPredict.FollowLogicState)
                    {
                        predict.m_state = MovementPredict.EliminateOffsetState;
                        predict.m_task.Cancel();
                    }
                }
                MovementPredict temp = RecyclableObject.Create <MovementPredict>();
                temp.m_state = MovementPredict.StopState;
                m_movement_predicts.Add(temp);
                StopMoveAnimation();
                //LogWrapper.LogDebug("PredictEntityMove, StopMoving, time =", GetCurrentTime());
            }
            break;

            default:
                break;
            }
        }