private AiData_UserSelf_General GetAiData(UserInfo user)
        {
            AiData_UserSelf_General data = user.GetAiStateInfo().AiDatas.GetData <AiData_UserSelf_General>();

            if (null == data)
            {
                data = new AiData_UserSelf_General();
                user.GetAiStateInfo().AiDatas.AddData(data);
            }
            return(data);
        }
示例#2
0
 public void Execute(UserInfo user, AiCommandDispatcher aiCmdDispatcher, long deltaTime)
 {
     if (user.GetAIEnable())
     {
         UserAiStateInfo userAi = user.GetAiStateInfo();
         if (userAi.CommandQueue.Count <= 0)
         {
             int curState = userAi.CurState;
             if (curState > (int)AiStateId.Invalid && curState < (int)AiStateId.MaxNum)
             {
                 if (m_Handlers.ContainsKey(curState))
                 {
                     UserAiStateHandler handler = m_Handlers[curState];
                     if (null != handler)
                     {
                         handler(user, aiCmdDispatcher, deltaTime);
                     }
                 }
                 else
                 {
                     LogSystem.Error("Illegal ai state: " + curState + " user:" + user.GetId());
                 }
             }
             else
             {
                 OnStateLogicInit(user, aiCmdDispatcher, deltaTime);
                 ChangeToState(user, (int)AiStateId.Idle);
             }
         }
         ExecuteCommandQueue(user, deltaTime);
     }
 }
示例#3
0
        private void IdleHandler(UserInfo user, AiCommandDispatcher aiCmdDispatcher, long deltaTime)
        {
            UserAiStateInfo info = user.GetAiStateInfo();

            user.GetMovementStateInfo().IsMoving = false;
            ChangeToState(user, (int)AiStateId.Wait);
        }
示例#4
0
        internal static void Execute(object msg, User user)
        {
            Msg_CR_UserMoveToPos move_msg = msg as Msg_CR_UserMoveToPos;

            if (move_msg == null)
            {
                return;
            }
            UserInfo charactor = user.Info;

            if (charactor == null)
            {
                LogSys.Log(LOG_TYPE.ERROR, "charactor {0} not exist", user.RoleId);
                return;
            }
            ///
            if (charactor.GetAIEnable())
            {
                MovementStateInfo msi = charactor.GetMovementStateInfo();
                msi.PositionX = move_msg.cur_pos_x;
                msi.PositionZ = move_msg.cur_pos_z;

                UserAiStateInfo asi = charactor.GetAiStateInfo();
                Vector3         pos = new Vector3(move_msg.target_pos_x, 0, move_msg.target_pos_z);
                asi.TargetPos          = pos;
                asi.IsTargetPosChanged = true;
                asi.ChangeToState((int)(AiStateId.Move));
            }
        }
        private void MoveHandler(UserInfo user, AiCommandDispatcher aiCmdDispatcher, long deltaTime)
        {
            if (user.IsDead())
            {
                return;
            }
            UserAiStateInfo         info = user.GetAiStateInfo();
            AiData_UserSelf_General data = GetAiData(user);
            Vector3 targetPos            = info.TargetPos;

            ScriptRuntime.Vector3 srcPos = user.GetMovementStateInfo().GetPosition3D();

            if (null != data && !IsReached(srcPos, targetPos))
            {
                if (info.IsTargetPosChanged)
                {
                    info.IsTargetPosChanged = false;
                    data.FoundPath.Clear();
                }
                PathToTarget(user, data.FoundPath, targetPos, deltaTime);
            }
            else
            {
                user.GetMovementStateInfo().StopMove();
                NotifyUserMove(user);
                info.Time = 0;
                data.Time = 0;
                data.FoundPath.Clear();
                ChangeToState(user, (int)AiStateId.Idle);
            }
        }
示例#6
0
        internal static Msg_RC_UserMove BuildUserMoveMessage(UserInfo user)
        {
            Msg_RC_UserMove userMoveBuilder = new Msg_RC_UserMove();

            if (user.GetMovementStateInfo().IsMoving)
            {
                userMoveBuilder.role_id        = user.GetId();
                userMoveBuilder.is_moving      = true;
                userMoveBuilder.move_direction = (float)user.GetMovementStateInfo().GetMoveDir();
                userMoveBuilder.face_direction = (float)user.GetMovementStateInfo().GetFaceDir();
                userMoveBuilder.cur_pos_x      = user.GetMovementStateInfo().GetPosition3D().X;
                userMoveBuilder.cur_pos_z      = user.GetMovementStateInfo().GetPosition3D().Z;
                UserAiStateInfo data = user.GetAiStateInfo();
                userMoveBuilder.target_pos_x         = user.GetMovementStateInfo().TargetPosition.X;
                userMoveBuilder.target_pos_z         = user.GetMovementStateInfo().TargetPosition.Z;
                userMoveBuilder.velocity_coefficient = (float)user.VelocityCoefficient;
            }
            else
            {
                userMoveBuilder.role_id   = user.GetId();
                userMoveBuilder.is_moving = false;
                userMoveBuilder.cur_pos_x = user.GetMovementStateInfo().GetPosition3D().X;
                userMoveBuilder.cur_pos_z = user.GetMovementStateInfo().GetPosition3D().Z;
            }
            return(userMoveBuilder);
        }
示例#7
0
        protected override void OnStateLogicInit(UserInfo user, AiCommandDispatcher aiCmdDispatcher, long deltaTime)
        {
            UserAiStateInfo info = user.GetAiStateInfo();

            info.Time   = 0;
            info.Target = 0;
        }
        protected override void OnStateLogicInit(UserInfo user, AiCommandDispatcher aiCmdDispatcher, long deltaTime)
        {
            UserAiStateInfo info = user.GetAiStateInfo();

            info.HomePos = user.GetMovementStateInfo().GetPosition3D();
            info.Time    = 0;
            user.GetMovementStateInfo().IsMoving = false;
        }
示例#9
0
        private void TickUser(UserInfo user, long delta)
        {
            IUserStateLogic logic = AiLogicManager.Instance.GetUserStateLogic(user.GetAiStateInfo().AiLogic);

            if (null != logic)
            {
                logic.Execute(user, m_AiCommandDispatcher, delta);
            }
        }
示例#10
0
        private void StopFindPath(UserInfo playerself, UserAiStateInfo aiInfo)
        {
            if (null == playerself || null == aiInfo)
            {
                return;
            }
            AiData_UserSelf_General data = playerself.GetAiStateInfo().AiDatas.GetData <AiData_UserSelf_General>();

            if (null == data)
            {
                data = new AiData_UserSelf_General();
                playerself.GetAiStateInfo().AiDatas.AddData(data);
            }
            playerself.GetMovementStateInfo().IsMoving = false;
            aiInfo.Time = 0;
            data.Time   = 0;
            data.FoundPath.Clear();
            aiInfo.ChangeToState((int)AiStateId.Idle);
        }
示例#11
0
        public void UserSkill(UserInfo user, AbstractUserStateLogic logic, int skillId, int targetId, ScriptRuntime.Vector3 targetPos, float targetAngle, int itemId)
        {
            UserSkillCommand cmd = m_UserSkillCommandPool.Alloc();

            if (null != cmd)
            {
                cmd.SetContext(user, logic);
                cmd.Init(skillId, targetId, targetPos, targetAngle, itemId);
                user.GetAiStateInfo().CommandQueue.Enqueue(cmd);
            }
        }
示例#12
0
        public void UserFace(UserInfo user, AbstractUserStateLogic logic)
        {
            UserFaceCommand cmd = m_UserFaceCommandPool.Alloc();

            if (null != cmd)
            {
                cmd.SetContext(user, logic);
                cmd.Init();
                user.GetAiStateInfo().CommandQueue.Enqueue(cmd);
            }
        }
示例#13
0
        internal static void Execute(object msg, User user)
        {
            Msg_CR_UserMoveToAttack attack_msg = msg as Msg_CR_UserMoveToAttack;

            if (attack_msg == null)
            {
                return;
            }
            UserInfo charactor = user.Info;

            if (charactor == null)
            {
                LogSys.Log(LOG_TYPE.ERROR, "charactor {0} not exist", user.RoleId);
                return;
            }
            ///
            if (charactor.GetAIEnable())
            {
                MovementStateInfo msi = charactor.GetMovementStateInfo();
                msi.PositionX = attack_msg.cur_pos_x;
                msi.PositionZ = attack_msg.cur_pos_z;

                UserAiStateInfo aiInfo = charactor.GetAiStateInfo();

                AiData_UserSelf_General data = charactor.GetAiStateInfo().AiDatas.GetData <AiData_UserSelf_General>();
                if (null == data)
                {
                    data = new AiData_UserSelf_General();
                    charactor.GetAiStateInfo().AiDatas.AddData(data);
                }
                charactor.GetMovementStateInfo().IsMoving = false;
                data.FoundPath.Clear();
                aiInfo.Time        = 0;
                aiInfo.Target      = attack_msg.target_id;
                aiInfo.IsAttacked  = false;
                aiInfo.AttackRange = attack_msg.attack_range;

                aiInfo.ChangeToState((int)AiStateId.Combat);
            }
        }
示例#14
0
 private void PushSkill(UserInfo playerself, Vector3 targetpos, float attackrange)
 {
     if (null != playerself && Vector3.Zero != targetpos)
     {
         UserAiStateInfo info = playerself.GetAiStateInfo();
         RevokeSkill(playerself, info);
         info.Time        = 0;
         info.TargetPos   = targetpos;
         info.AttackRange = attackrange;
         info.IsAttacked  = false;
         info.ChangeToState((int)AiStateId.Combat);
     }
 }
示例#15
0
        private void ExecuteCommandQueue(UserInfo user, long deltaTime)
        {
            UserAiStateInfo userAi = user.GetAiStateInfo();

            while (userAi.CommandQueue.Count > 0)
            {
                IAiCommand cmd = userAi.CommandQueue.Peek();
                if (cmd.Execute(deltaTime))
                {
                    userAi.CommandQueue.Dequeue();
                }
                else
                {
                    break;
                }
            }
        }
示例#16
0
        private void Combat(UserInfo playerself, int targetId, float attackrange)
        {
            if (null != playerself && m_lastSelectObjId != targetId)
            {
                UserAiStateInfo info = playerself.GetAiStateInfo();
                if ((int)AiStateId.Move == info.CurState)
                {
                    StopFindPath(playerself, info);
                }
                info.Time        = 0;
                info.Target      = targetId;
                info.IsAttacked  = false;
                info.AttackRange = attackrange;

                info.ChangeToState((int)AiStateId.Combat);
            }
        }
示例#17
0
        private void MoveHandler(UserInfo user, AiCommandDispatcher aiCmdDispatcher, long deltaTime)
        {
            if (user.IsDead())
            {
                user.GetMovementStateInfo().IsMoving = false;
                ChangeToState(user, (int)AiStateId.Wait);
                return;
            }
            UserAiStateInfo info = user.GetAiStateInfo();

            info.Time += deltaTime;
            if (info.Time > 10)
            {
                info.Time = 0;
                Vector3 srcPos    = user.GetMovementStateInfo().GetPosition3D();
                Vector3 targetPos = user.GetMovementStateInfo().TargetPosition;
                if (!IsReached(srcPos, targetPos))
                {
                    float angle = Geometry.GetYAngle(new Vector2(srcPos.X, srcPos.Z), new Vector2(targetPos.X, targetPos.Z));
                    user.GetMovementStateInfo().SetMoveDir(angle);
                    user.GetMovementStateInfo().IsMoving = true;
                }
            }
        }
示例#18
0
        private void IdleHandler(UserInfo user, AiCommandDispatcher aiCmdDispatcher, long deltaTime)
        {
            if (user.IsDead())
            {
                return;
            }
            UserAiStateInfo info = user.GetAiStateInfo();

            info.Time += deltaTime;
            if (info.Time > 100)
            {
                info.Time = 0;
                CharacterInfo target = null;
                if (info.IsAttacked && m_AttackRangeLast > 0)
                {
                    if (info.Target > 0 /* || info.TargetPos != Vector3.Zero*/)
                    {
                        target = AiLogicUtility.GetSeeingLivingCharacterInfoHelper(user, info.Target);
                        if (null == target)
                        {
                            info.Target = 0;
                            target      = AiLogicUtility.GetNearstTargetHelper(user, CharacterRelation.RELATION_ENEMY);
                        }
                    }
                    if (null != target)
                    {
                        info.Time         = 0;
                        info.Target       = target.GetId();
                        info.IsAttacked   = false;
                        info.AttackRange  = m_AttackRangeLast;
                        m_AttackRangeLast = 0;
                        ChangeToState(user, (int)AiStateId.Combat);
                    }
                }
            }
        }
示例#19
0
        public void Tick()
        {
            long now = TimeUtility.GetServerMilliseconds();

            m_LastTickIntervalMs = now - m_LastTickTime;

            m_LastTickTime = now;

            if (WorldSystem.Instance.IsObserver && !WorldSystem.Instance.IsFollowObserver)
            {
                bool  keyPressed = false;
                float x = 0.5f, y = 0.5f;
                if (GfxSystem.IsKeyPressed(Keyboard.Code.A))
                {
                    x          = 0.1f;
                    keyPressed = true;
                }
                else if (GfxSystem.IsKeyPressed(Keyboard.Code.D))
                {
                    x          = 0.9f;
                    keyPressed = true;
                }
                if (GfxSystem.IsKeyPressed(Keyboard.Code.W))
                {
                    y          = 0.1f;
                    keyPressed = true;
                }
                else if (GfxSystem.IsKeyPressed(Keyboard.Code.S))
                {
                    y          = 0.9f;
                    keyPressed = true;
                }
                if (keyPressed)
                {
                    WorldSystem.Instance.UpdateObserverCamera(x, y);
                }
                return;
            }

            // if move input is disable
            // MotionStatus is MoveStop, and MotionChanged is reflect the change accordingly
            // pm_.Update(EnableMoveInput);

            UserInfo playerself = WorldSystem.Instance.GetPlayerSelf();

            if (null == playerself)
            {
                return;
            }

            Vector3 pos       = playerself.GetMovementStateInfo().GetPosition3D();
            Vector3 mouse_pos = new Vector3(GfxSystem.GetMouseX(), GfxSystem.GetMouseY(), GfxSystem.GetMouseZ());//GfxSystem.Instance.MainScene.GetMousePos(pos.Y);

            if (pm_.MotionStatus == PlayerMovement.Motion.Moving)
            {
                if (pm_.MotionChanged)
                {
                    WorldSystem.Instance.InputMoveDir = pm_.MoveDir;
                    playerself.GetMovementStateInfo().SetWantMoveDir(pm_.MoveDir);

                    if (WorldSystem.Instance.IsPveScene())
                    {
                        playerself.GetMovementStateInfo().SetMoveDir(pm_.MoveDir);
                        playerself.GetMovementStateInfo().IsMoving       = true;
                        playerself.GetMovementStateInfo().TargetPosition = Vector3.Zero;
                    }
                    else
                    {
                        NetworkSystem.Instance.SyncPlayerMoveStart((float)pm_.MoveDir);
                    }

                    if (EnableRotateInput)
                    {
                        MovementStateInfo msi = playerself.GetMovementStateInfo();
                        msi.SetFaceDir(pm_.MoveDir);
                        NetworkSystem.Instance.SyncFaceDirection((float)pm_.MoveDir);
                    }
                }
            }
            else
            {
                if (pm_.MotionChanged)
                {
                    WorldSystem.Instance.LastMoveDirAdjust = 0;

                    if (WorldSystem.Instance.IsPveScene())
                    {
                        playerself.GetMovementStateInfo().IsMoving = false;
                    }
                    else
                    {
                        NetworkSystem.Instance.SyncPlayerMoveStop();
                    }
                }
            }

            old_mouse_pos_ = mouse_pos_;
            mouse_pos_.X   = GfxSystem.GetMouseX();
            mouse_pos_.Y   = GfxSystem.GetMouseY();

            UserAiStateInfo aiInfo = playerself.GetAiStateInfo();

            if (null != aiInfo && (int)AiStateId.Idle == aiInfo.CurState)
            {
                m_lastSelectObjId = -1;
            }
        }
示例#20
0
 public void ChangeToState(UserInfo user, int state)
 {
     user.GetAiStateInfo().ChangeToState(state);
 }
示例#21
0
        private void TouchHandle(int what, GestureArgs e)
        {
            UserInfo playerself = WorldSystem.Instance.GetPlayerSelf();

            if (null == playerself || null == e)
            {
                return;
            }
            if ((int)TouchEvent.Cesture == what)
            {
                string ename = e.name;
                if (GestureEvent.OnSingleTap.ToString() == ename)
                {
                    if (EnableMoveInput)
                    {
                        if (WorldSystem.Instance.IsPveScene())
                        {
                            if (e.selectedObjID < 0)
                            {
                                FindPath(playerself, new Vector3(e.airWelGamePosX, e.airWelGamePosY, e.airWelGamePosZ), e.towards);
                            }
                            else
                            {
                                Combat(playerself, e.selectedObjID, e.attackRange);
                            }
                            m_lastSelectObjId = e.selectedObjID;
                            ///
                            GfxSystem.PublishGfxEvent("Op_InputEffect", "Input", GestureEvent.OnSingleTap, e.airWelGamePosX, e.airWelGamePosY, e.airWelGamePosZ, e.selectedObjID < 0 ? false : true, true);
                        }
                        else
                        {
                            Vector3 world_pos = new Vector3(GfxSystem.GetTouchRayPointX(), GfxSystem.GetTouchRayPointY(), GfxSystem.GetTouchRayPointZ());
                            NetworkSystem.Instance.SyncPlayerFindPath(world_pos);
                        }
                    }
                }
                else if (GestureEvent.OnFingerMove.ToString() == ename)
                {
                    if (EnableMoveInput)
                    {
                        if (TouchType.Attack == e.moveType)
                        {
                            UpdateTowards(playerself, e.towards);
                        }
                    }
                }
                else if (GestureEvent.OnSkillStart.ToString() == ename)
                {
                    if (null != playerself)
                    {
                        UserAiStateInfo info = playerself.GetAiStateInfo();
                        if ((int)AiStateId.Move == info.CurState)
                        {
                            StopFindPath(playerself, info);
                        }
                    }
                }
                else if (GestureEvent.OnEasyGesture.ToString() == ename)
                {
                    Vector3 targetpos = new Vector3(e.startGamePosX, e.startGamePosY, e.startGamePosZ);
                    if (Vector3.Zero != targetpos)
                    {
                        PushSkill(playerself, targetpos, e.attackRange);
                    }
                }

                //LogSystem.Debug("userid:{0}, input event:{1}", playerself.GetId(), e.name);
            }
        }
示例#22
0
 public void PushState(UserInfo user, int state)
 {
     user.GetAiStateInfo().PushState(state);
 }
示例#23
0
 public void PopState(UserInfo user)
 {
     user.GetAiStateInfo().PopState();
 }
        private void PursuitHandler(UserInfo user, AiCommandDispatcher aiCmdDispatcher, long deltaTime)
        {
            if (user.IsDead())
            {
                return;
            }
            UserAiStateInfo         info = user.GetAiStateInfo();
            AiData_UserSelf_General data = GetAiData(user);

            if (null != data)
            {
                if (info.Target > 0)
                {
                    CharacterInfo target = AiLogicUtility.GetLivingCharacterInfoHelper(user, info.Target);
                    if (null != target)
                    {
                        float   dist                 = info.AttackRange - 1.0f;
                        Vector3 targetPos            = target.GetMovementStateInfo().GetPosition3D();
                        ScriptRuntime.Vector3 srcPos = user.GetMovementStateInfo().GetPosition3D();
                        float powDist                = Geometry.DistanceSquare(srcPos, targetPos);
                        if (powDist < dist * dist)
                        {
                            user.GetMovementStateInfo().IsMoving = false;
                            info.Time = 0;
                            data.Time = 0;
                            ChangeToState(user, (int)AiStateId.Combat);
                            NotifyUserMove(user);
                        }
                        else
                        {
                            info.Time += deltaTime;
                            if (info.Time > 100)
                            {
                                info.Time = 0;
                                CharacterInfo target2 = GetCanAttackUserTarget(user);
                                if (null == target2)
                                {
                                    AiLogicUtility.GetNearstTargetHelper(user, CharacterRelation.RELATION_ENEMY);
                                }
                                if (null == target2 || target == target2)
                                {
                                    PathToTarget(user, data.FoundPath, targetPos, deltaTime);
                                }
                                else
                                {
                                    info.Target = target2.GetId();
                                    return;
                                }
                            }
                        }
                    }
                    else
                    {
                        user.GetMovementStateInfo().StopMove();
                        NotifyUserMove(user);
                        info.Time = 0;
                        data.Time = 0;
                        data.FoundPath.Clear();
                        ChangeToState(user, (int)AiStateId.Idle);
                    }
                }
                else
                {
                    float   dist                 = info.AttackRange;
                    Vector3 targetPos            = info.TargetPos;
                    ScriptRuntime.Vector3 srcPos = user.GetMovementStateInfo().GetPosition3D();
                    float powDist                = Geometry.DistanceSquare(srcPos, targetPos);
                    if (powDist < dist * dist)
                    {
                        user.GetMovementStateInfo().IsMoving = false;
                        info.Time = 0;
                        data.Time = 0;
                        ChangeToState(user, (int)AiStateId.Combat);
                        NotifyUserMove(user);
                    }
                    else
                    {
                        info.Time += deltaTime;
                        if (info.Time > 100)
                        {
                            info.Time = 0;
                            PathToTarget(user, data.FoundPath, targetPos, deltaTime);
                        }
                    }
                }
            }
        }
        private void PathToTarget(UserInfo user, AiPathData data, Vector3 pathTargetPos, long deltaTime)
        {
            UserAiStateInfo info = user.GetAiStateInfo();

            if (null != data)
            {
                data.UpdateTime += deltaTime;
                ScriptRuntime.Vector3 srcPos = user.GetMovementStateInfo().GetPosition3D();
                float dir           = user.GetMovementStateInfo().GetMoveDir();
                bool  findObstacle  = false;
                bool  havePathPoint = data.HavePathPoint;
                if (havePathPoint)//沿路点列表移动的逻辑
                {
                    Vector3 targetPos = data.CurPathPoint;
                    if (!data.IsReached(srcPos))//向指定路点移动(避让移动过程)
                    {
                        user.GetMovementStateInfo().TargetPosition = targetPos;
                        float angle = Geometry.GetYAngle(new Vector2(srcPos.X, srcPos.Z), new Vector2(targetPos.X, targetPos.Z));
                        if (!Geometry.IsSameDouble(angle, user.GetMovementStateInfo().GetMoveDir()))
                        {
                            user.GetMovementStateInfo().SetFaceDir(angle);
                            user.GetMovementStateInfo().SetMoveDir(angle);
                            user.GetMovementStateInfo().IsMoving = true;
                            NotifyUserMove(user);
                        }
                    }
                    else//改变路点或结束沿路点移动
                    {
                        data.UseNextPathPoint();
                        if (data.HavePathPoint)
                        {
                            targetPos = data.CurPathPoint;
                            user.GetMovementStateInfo().TargetPosition = targetPos;
                            float angle = Geometry.GetYAngle(new Vector2(srcPos.X, srcPos.Z), new Vector2(targetPos.X, targetPos.Z));
                            user.GetMovementStateInfo().SetFaceDir(angle);
                            user.GetMovementStateInfo().SetMoveDir(angle);
                            user.GetMovementStateInfo().IsMoving = true;
                            NotifyUserMove(user);
                        }
                        else
                        {
                            data.Clear();
                        }
                    }
                }
                if (!havePathPoint || findObstacle)//获得路点过程(寻路)
                {
                    data.Clear();
                    Vector3 targetPos = pathTargetPos;
                    if (Geometry.DistanceSquare(srcPos, targetPos) > 400)
                    {
                        targetPos = user.SpatialSystem.CalcNearstReachablePoint(srcPos, targetPos, 20);
                    }
                    bool canGo = true;

                    /*
                     * if (!user.SpatialSystem.GetCellMapView(user.AvoidanceRadius).CanPass(targetPos)) {
                     * if (!AiLogicUtility.GetWalkablePosition(user.SpatialSystem.GetCellMapView(user.AvoidanceRadius), targetPos, srcPos, ref targetPos))
                     *  canGo = false;
                     * }*/
                    if (canGo)
                    {
                        List <Vector3> posList = null;
                        if (user.SpatialSystem.CanPass(user.SpaceObject, targetPos))
                        {
                            posList = new List <Vector3>();
                            posList.Add(srcPos);
                            posList.Add(targetPos);
                        }
                        else
                        {
                            long stTime = TimeUtility.GetElapsedTimeUs();
                            posList = user.SpatialSystem.FindPath(srcPos, targetPos, user.AvoidanceRadius);
                            long endTime  = TimeUtility.GetElapsedTimeUs();
                            long calcTime = endTime - stTime;
                            if (calcTime > 1000)
                            {
                                //LogSystem.Warn("pvp FindPath consume {0} us,user:{1} from:{2} to:{3} radius:{4} pos:{5}", calcTime, user.GetId(), srcPos.ToString(), targetPos.ToString(), user.AvoidanceRadius, user.GetMovementStateInfo().GetPosition3D().ToString());
                            }
                        }
                        if (posList.Count >= 2)
                        {
                            data.SetPathPoints(posList[0], posList, 1);
                            targetPos = data.CurPathPoint;
                            user.GetMovementStateInfo().TargetPosition = targetPos;
                            float angle = Geometry.GetYAngle(new Vector2(srcPos.X, srcPos.Z), new Vector2(targetPos.X, targetPos.Z));
                            user.GetMovementStateInfo().SetFaceDir(angle);
                            user.GetMovementStateInfo().SetMoveDir(angle);
                            user.GetMovementStateInfo().IsMoving = true;
                            NotifyUserMove(user);
                        }
                        else
                        {
                            user.GetMovementStateInfo().IsMoving = false;
                            NotifyUserMove(user);
                        }
                    }
                    else
                    {
                        user.GetMovementStateInfo().IsMoving = false;
                        NotifyUserMove(user);
                    }
                }
            }
        }
        private void CombatHandler(UserInfo user, AiCommandDispatcher aiCmdDispatcher, long deltaTime)
        {
            if (user.IsDead())
            {
                return;
            }
            UserAiStateInfo info = user.GetAiStateInfo();

            info.Time += deltaTime;
            if (info.Time > 100)
            {
                AiData_UserSelf_General data = GetAiData(user);
                if (null != data)
                {
                    data.Time += info.Time;
                    info.Time  = 0;
                    ///
                    CharacterInfo target    = AiLogicUtility.GetSeeingLivingCharacterInfoHelper(user, info.Target);
                    Vector3       targetPos = Vector3.Zero;
                    float         dist      = info.AttackRange;
                    if (null != target)
                    {
                        targetPos = target.GetMovementStateInfo().GetPosition3D();
                    }
                    else
                    {
                        targetPos = info.TargetPos;
                    }
                    Vector3 srcPos  = user.GetMovementStateInfo().GetPosition3D();
                    float   powDist = Geometry.DistanceSquare(srcPos, targetPos);
                    if (!info.IsAttacked)
                    {
                        if (powDist < dist * dist)
                        {
                            data.Time        = 0;
                            info.AttackRange = 0;
                            info.IsAttacked  = true;
                            float dir = Geometry.GetYAngle(new Vector2(srcPos.X, srcPos.Z), new Vector2(targetPos.X, targetPos.Z));
                            user.GetMovementStateInfo().SetFaceDir(dir);
                            user.GetMovementStateInfo().SetMoveDir(dir);
                            if (null != target)
                            {
                                if (null != OnUserStartAttack)
                                {
                                    OnUserStartAttack(user, targetPos.X, targetPos.Y, targetPos.Z);
                                }
                            }
                            else
                            {
                                if (null != OnUserSkill)
                                {
                                    OnUserSkill(user);
                                }
                            }
                            ///
                            user.GetMovementStateInfo().StopMove();
                            NotifyUserMove(user);
                            info.Time = 0;
                            data.FoundPath.Clear();
                            ChangeToState(user, (int)AiStateId.Idle);
                        }
                        else
                        {
                            if (null != OnSkillPursuit)
                            {
                                OnSkillPursuit(user);
                            }
                            user.GetMovementStateInfo().StopMove();
                            NotifyUserMove(user);
                            info.Time       = 0;
                            info.IsAttacked = false;
                            data.FoundPath.Clear();
                            ChangeToState(user, (int)AiStateId.Pursuit);
                        }
                    }
                }
                else
                {
                    info.Time = 0;
                }
            }
        }