// Input -----------------------
    // avalia o input no frame
    private void InputManager()
    {
        // reseta a aceleraçao determinada e direcçao
        char_acceleration_ = 0f;
        target_direction_  = Vector3.zero;

        // avalia o input direcional (Vertical)
        // caso exista input vertical
        if (Input.GetAxis("Vertical") != 0f)
        {
            // determinar a direcçao do jogador quando esta na forma de Aike
            // varia a aceleraçao utilizando o inout system do Unity
            char_acceleration_ += char_info_.AikeAceleration *
                                  Mathf.Abs(Input.GetAxis("Vertical"));

            // define a direcçao alvo igual á direclao da camera
            target_direction_ += char_system_.ProjectDirection() *
                                 Input.GetAxis("Vertical");
        }

        // caso exista input horizontal
        if (Input.GetAxis("Horizontal") != 0f)
        {
            // determina a direcçao do jogador quando esta na forma de AIke
            char_acceleration_ += char_info_.AikeAceleration *
                                  Mathf.Abs(Input.GetAxis("Horizontal"));

            // define a direcçao alvo resultante da direcçao
            target_direction_ += (Quaternion.AngleAxis(90f, this.transform.up)
                                  * char_system_.ProjectDirection() * Input.GetAxis("Horizontal")).normalized;
        }
        // normaliza a direcçao
        target_direction_.Normalize();
        AjustCharRotation(); // ajusta a rotaçao do personagem á normal do terreno

        // roda o player para a direcçao calculada
        // so deve mudar de direcçao se estiveer no chao
        if (target_direction_ != Vector3.zero && GroundedCheck())
        {
            char_transform_.rotation = Quaternion.Lerp(char_transform_.rotation,
                                                       Quaternion.LookRotation(Vector3.ProjectOnPlane(target_direction_, char_transform_.up),
                                                                               char_transform_.up), char_info_.AikeRotationSpeed * game_settings_.PlayerTimeMultiplication());
        }
    }
Exemple #2
0
    // Input Direcional---------
    // avalia input no frame
    private void InputManager()
    {
        // reseta variaveis de loop
        target_direction_  = Vector3.zero;
        char_acceleration_ = 0f;

        // avalia o input directional (Vertical)
        // caso exista input vertical
        if (Input.GetAxis("Vertical") != 0f)
        {
            // define a direcçao alvo igual á direcçao da camera projectada para o
            // dependendo do input, incrementa ou decrementa a aceleraçao
            if (Input.GetAxis("Vertical") > 0f)
            {
                // personagem, Como o arif nao consegue se deslocar na direcçao da camera
                // a direcçao é sempre igual á da camera
                target_direction_ += _char_system_.ProjectDirection();

                // determinar a direcçao do jogador quando está na forma de Arif
                // varia a aceleraçao utilizando o input system do Unity
                char_acceleration_ += char_info_.ArifAceleration *
                                      Mathf.Abs(Input.GetAxis("Vertical"));
            }
            // caso esteja a travar
            else
            {
                // deve reduzir a velocidade de acordo com o valor de drag
                char_acceleration_ -= char_info_.ArifBreakSpeed * Mathf.Abs(Input.GetAxis("Vertical"));
            }
        }


        // caso exista input horizontal
        if (Input.GetAxis("Horizontal") != 0f)
        {
            // determina a direcçao causada por este input
            target_direction_ += (Quaternion.AngleAxis(90f, char_info_.GetInputUpDir()) *
                                  _char_system_.ProjectDirection() * Input.GetAxis("Horizontal")).normalized;
        }

        // normaliza a direcçao
        target_direction_.Normalize();

        // roda o jogador de acordo com a direcçao alvo determinada
        if (target_direction_ != Vector3.zero)
        {
            char_transform_.forward = Vector3.Lerp(char_transform_.forward,
                                                   target_direction_, char_info_.ArifRotationSpeed * game_settings_.PlayerTimeMultiplication());
        }
        else
        {
            // caso nao exista input, o modelo deve se orientar
            char_transform_.rotation = Quaternion.Lerp(char_transform_.rotation, Quaternion.LookRotation(
                                                           Vector3.ProjectOnPlane(char_transform_.forward, Vector3.up), Vector3.up),
                                                       char_info_.ArifRotationSpeed * game_settings_.PlayerTimeMultiplication());
        }

        // determina o valor de roll de acordo com o angulo formado entre a direcçao alvo
        // e a direcçao do jogador
        // altera o roll do objecto de acordo com
        calculated_roll_value_ =
            Vector3.SignedAngle(Vector3.ProjectOnPlane(
                                    target_direction_, char_transform_.up), char_transform_.forward, char_transform_.up);

        // caso o valor do angulo for maior que a rotaçao no fram
        // calcula o valor intermedio para que a rotaçao seja mais homogenea
        char_roll_angle_ = Mathf.LerpAngle(
            char_roll_angle_, calculated_roll_value_,
            char_info_.ArifRollSpeed * game_settings_.PlayerTimeMultiplication());

        // adiciona á rotaçao, o valor de roll determinado anteriormente
        if (Mathf.Abs(char_roll_angle_) > char_info_.ArifRollSpeed * game_settings_.PlayerTimeMultiplication())
        {
            char_transform_.rotation = Quaternion.Euler(char_transform_.rotation.eulerAngles.x,
                                                        char_transform_.rotation.eulerAngles.y, char_roll_angle_);
        }
    }