Ejemplo n.º 1
0
        void Update()
        {
            moveFlag = moveCtrl.GetMoveFlag();
            //스킬 커맨드 입력 부분.
            if (mgr.GetCtrlPossible().Skill == true)
            {
                //회피기
                if (Input.GetKeyDown(KeyCode.Space))
                {
                    //방향키 입력 후 Space입력은 일반회피.
                    if (moveFlag.forward || moveFlag.backward || moveFlag.right || moveFlag.left)
                    {
                        //일반회피
                        if (mgr.GetEP() > T2.Skill.Evasion.GetInstance().iDecPoint)
                        {
                            ChangeSkill(T2.Skill.Evasion.GetInstance());
                        }
                    }
                    else
                    {
                        //긴급회피
                        //방향키 입력x
                        //캔슬이 가능한 스킬은 현재 사용중인 스킬이 본인의 스킬인지 체크해야 한다.
                        if (mgr.PointCheck(Manager.SkillType.EP, T2.Skill.Evasion_E.GetInstance().iDecPoint))
                        {
                            if (mgr.GetEP() > T2.Skill.Evasion_E.GetInstance().iDecPoint)
                            {
                                ChangeSkill(T2.Skill.Evasion_E.GetInstance());
                            }
                        }
                    }
                }



                //SeventhFlow_v1
                if (Input.GetKeyDown(KeyCode.Q))
                {
                    if (mgr.PointCheck(SeventhFlow.GetInstance().PointType, T2.Skill.SeventhFlow.GetInstance().iDecPoint))
                    {
                        ChangeSkill(T2.Skill.SeventhFlow.GetInstance());
                    }
                }
            }


            //스킬 실행 부분.
            //Execute에는 기본적으로 피격으로 인한 스킬 정지 코드가 있다.
            if (curSkill != T2.Skill.IdleSkill.GetInstance())
            {
                curSkill.Execute(this);
            }
        }
Ejemplo n.º 2
0
        void Update()
        {
            h = Input.GetAxis("Horizontal");
            v = Input.GetAxis("Vertical");

            Vector3 moveDir = (Vector3.forward * v) + (Vector3.right * h);

            //전력질주의 캐릭터 방향을 정하는 'targetRot'변수를 설정해주는 함수,
            CalcTargetRot();

            #region <switch(moveState)>
            switch (moveState)
            {
            case MoveState.Stop:
                moveDir = Vector3.zero;
                //h = v = 0.0f;
                fMoveSpeed = 5.0f;
                oSprintEffect.SetActive(false);
                //oSprintEffect.GetComponentInChildren<ParticleSystem>().playOnAwake = false;
                break;

            case MoveState.Run:
                //fMoveSpeed가 Walk상태에서의 MaxSpeed보다 높을 떄, 즉 Run상태의 이동속도 구간이였다면.
                //SpeedDamp 수치를 높여 이동속도를 빠르게 낮춘다(run->walk).
                //반대 상황(walk->run)에서는 속도를 천천히 높이기 위해 SpeedDamp 수치를 낮춘다.
                if (fMoveSpeed > T2.Stat.MAX_RUN_MOVE)
                {
                    fMoveSpeedDamp = 10.0f;
                }
                else
                {
                    fMoveSpeedDamp = 1.0f;
                }
                fMaxMoveSpeed = T2.Stat.MAX_RUN_MOVE;

                oSprintEffect.SetActive(false);
                break;

            case MoveState.Sprint:
                fMoveSpeedDamp = 0.8f;
                fMaxMoveSpeed  = T2.Stat.MAX_SPRINT_MOVE;

                if (fMoveSpeed > 12.0f)
                {
                    oSprintEffect.SetActive(true);
                }
                break;
            }
            #endregion

            #region <Groggy>
            if (mgr.GetEP() < 0.0f)
            {
                bGroggy = true;
            }

            if (bGroggy)
            {
                if (groggyTimer < groggyTime)
                {
                    if (mgr.GetCtrlPossible().Sprint == true)
                    {
                        mgr.SetCtrlPossible(T2.Manager.CtrlPossibleIndex.Sprint, false);
                    }
                    groggyTimer += Time.deltaTime;
                }
                else
                {
                    mgr.SetCtrlPossible(T2.Manager.CtrlPossibleIndex.Sprint, true);
                    bGroggy     = false;
                    groggyTimer = 0.0f;
                }
            }
            #endregion

            #region <Input WASD>
            if (Input.GetKeyUp(KeyCode.W))
            {
                moveFlag.forward = false; h = 0.0f;
            }
            if (Input.GetKeyUp(KeyCode.S))
            {
                moveFlag.backward = false; h = 0.0f;
            }
            if (Input.GetKeyUp(KeyCode.D))
            {
                moveFlag.right = false; v = 0.0f;
            }
            if (Input.GetKeyUp(KeyCode.A))
            {
                moveFlag.left = false; v = 0.0f;
            }

            if (mgr.GetCtrlPossible().Run == true)
            {
                if (Input.GetKey(KeyCode.W))
                {
                    moveFlag.forward = true;
                }
                if (Input.GetKey(KeyCode.S))
                {
                    moveFlag.backward = true;
                }
                if (Input.GetKey(KeyCode.D))
                {
                    moveFlag.right = true;
                }
                if (Input.GetKey(KeyCode.A))
                {
                    moveFlag.left = true;
                }
            }
            //else
            //{
            //    moveFlag.forward = false;
            //    moveFlag.backward = false;
            //    moveFlag.right = false;
            //    moveFlag.left = false;
            //    //h = v = 0.0f;
            //}
            #endregion

            #region <MoveState Change>
            //걷기상태가 가능상태여야 전력질주도 가능하도록 한다.
            if (mgr.GetCtrlPossible().Run == true)
            {
                if (moveFlag.forward || moveFlag.backward || moveFlag.right || moveFlag.left)
                {
                    if (Input.GetKey(KeyCode.LeftShift) && mgr.GetCtrlPossible().Sprint == true)
                    {
                        moveState = MoveState.Sprint;
                    }
                    else
                    {
                        moveState = MoveState.Run;
                    }
                }
                else
                {
                    moveState = MoveState.Stop;
                }
            }


            #endregion

            //카메라 줌 인,아웃
            if (moveState == MoveState.Sprint)
            {
                if (fMoveSpeed > 12.0f)
                {
                    mainCamera.fieldOfView = Mathf.Lerp(mainCamera.fieldOfView, fSprintFOV, Time.deltaTime * fFOV_ZoomSpeed);
                }
            }
            else
            {
                mainCamera.fieldOfView = Mathf.Lerp(mainCamera.fieldOfView, fOrizinFOV, Time.deltaTime * fFOV_ZoomSpeed);
            }

            if (mgr.GetCtrlPossible().Run == true)
            {
                //이동 처리
                if (moveFlag.forward || moveFlag.backward || moveFlag.right || moveFlag.left)
                {
                    //플레이어를 카메라 정면방향으로 각도를 유지시킨다.
                    float CamRot = Camera.main.transform.eulerAngles.y;
                    transform.rotation = Quaternion.Euler(0.0f, CamRot, 0.0f);

                    //if (moveState == MoveState.Run)
                    //{
                    //    //전력질주일 때, 바뀌어버린 캐릭터(모델)의 각도를 정면으로 '보간'하며 바꾸어준다.
                    //    fRunRot = Mathf.LerpAngle(fRunRot, CamRot, Time.deltaTime * fCharRotSpeed + (fCharRotSpeed * 0.01f));
                    //    trPlayerModel.rotation = Quaternion.Euler(0.0f, fRunRot, 0.0f);

                    //    //transform.Rotate(Vector3.up * Time.deltaTime * fRotSpeed * Input.GetAxis("Mouse X"));
                    //}
                    //else if (moveState == MoveState.Sprint)
                    //{
                    #region <180도 회전>
                    //float fCurRot = transform.eulerAngles.y;
                    //fCurRot = Rotation360Clamp(fCurRot);
                    //fTargetRot = Rotation360Clamp(fTargetRot);

                    //float fRotGap = fCurRot - fTargetRot;
                    //if (fRotGap < 0.0f) fRotGap += 360.0f;

                    //if (fRotGap > 170.0f && fRotGap < 190.0f)
                    //{
                    //    bOppositRotation = true;
                    //}

                    ////좌우, 상하 180도 회전을 하는 경우.
                    //if (bOppositRotation)
                    //{
                    //    if (fRotGap < 10.0f || fRotGap > 350.0f)
                    //    {
                    //        fMoveSpeed = 5.0f;
                    //        bOppositRotation = false;
                    //    }
                    //    else
                    //    {
                    //        fMoveSpeed = 0.0f;
                    //    }

                    //    //targetRot각도로 fSprintRot을 설정.
                    //    //Lerp할 때마다 일정 수치를 상수값으로 항상 증감되도록 하여 끝부분에 아주 느려지는 부분을 보완한다.
                    //    fSprintRot = Mathf.LerpAngle(fSprintRot, fTargetRot, Time.deltaTime * fCharRotSpeed + (fCharRotSpeed * 0.001f));
                    //}
                    //else
                    //    fSprintRot = Mathf.LerpAngle(fSprintRot, fTargetRot, Time.deltaTime * fCharRotSpeed);
                    #endregion

                    //캐릭터를 기준으로 8방향 각도가 구해진 fTargetRot으로 보간하여 fSprintRot을 구한다.
                    fSprintRot             = Mathf.LerpAngle(fSprintRot, fTargetRot, Time.deltaTime * fCharRotSpeed + (fCharRotSpeed * 0.01f));
                    trPlayerModel.rotation = Quaternion.Euler(0.0f, fSprintRot, 0.0f);
                    //}

                    float fAngle = Vector3.Angle(transform.forward, trPlayerModel.forward);

                    //if (Vector3.Cross(transform.forward, trPlayerModel.forward).y < -0.1f)
                    //    fAngle -= 180.0f;
                    //print(fAngle);

                    float test = transform.eulerAngles.y - trPlayerModel.eulerAngles.y;
                    if (test < 0.0f)
                    {
                        test += 360.0f;
                    }
                    print(test);


                    animator.SetFloat("fAngle", test);



                    fMoveSpeed = Mathf.Lerp(fMoveSpeed, fMaxMoveSpeed, Time.deltaTime * fMoveSpeedDamp);

                    moveDir = transform.TransformDirection(moveDir);
                    controller.Move(moveDir * fMoveSpeed * Time.deltaTime);
                }
                //정지 처리
                else
                {
                    animator.SetFloat("fAngle", 0.0f);
                    //GetAxis의 수치가 떨어지는 시간이 존재하기 때문에 캐릭터를 곧바로 정지시키기 위해 Vector3.zero로 초기화한다.
                    moveState = MoveState.Stop;
                }
            }
        }