Unity Spain

Hola!
 
He hecho que, cuando mi player está cayéndose desde "x" altura, la cámara mire hacia el suelo, en plan "mira, te vas a estrellar",
y luego pierde el control de movimiento de la cámara mientras está cayendo, y lo recupera nuevamente cuando llega al suelo (si es que sobrevive).
 
_________________________________________________________________________________________________
 
Todo esto funciona perfecto.
Pero como problema es un poco raro, lo explicaré como si fueran pasos:
 

1. 
      Me tiro por el precipicio.
   


2. 
      Muevo la cámara hacia todos lados, simplemente para ver la transición de la cámara en cuanto comience a rotar hacia el suelo.
   


3. 
      Cuando llego a "x" altura, la cámara empieza a hacerle focus al suelo, y aparte ya no puedo mover más la cámara (tal y como yo quiero).
   


4. 
      Finalmente llego al suelo, y hago que el FOV de la cámara disminuya bastante para dar cierto efecto cuando choco contra el suelo.
   


5. 
      Pasan unas milésimas de segundo y el FOV vuelve a la normalidad, y aparte ya tengo de nuevo el control de la cámara!
   


6. 
      [EL PROBLEMA]: Lo que ocurre cuando me devuelve el control de la cámara (al final del en el paso nº5), 
   


7. 
      es que la rotación de la cámara vuelve a la posición en donde la dejé por última vez, en el paso nº2!!!
   

Ése es el problema!
 
Es decir,
me tiro...
me quedo mirando hacia el cielo (por ejemplo)...
la cámara comienza a encarar el suelo...
entonces llego al suelo y hace el efecto del fov, y oh sí todo muy genial...
y luego la cámara vuelve a mirar al cielo repentinamente como si Jesucristo le estuviese hablando.
 
_________________________________________________________________________________________________
 
Bueno, espero haberme hecho entender con esto.
Aquí pongo el código, para tratar de que no sea tan confuso:
 

using UnityEngine;
using System.Collections;
[DisallowMultipleComponent]
public class CameraHitGround : MonoBehaviour {
    private GameObject _player;
    private PlayerController _playerController = null;
    private CameraController _cameraController = null;
  
    private Transform _target;
  
    private float _hitFOV = 20f;
    private float _normalFOV = 72f;
    private float _hitLerpSpeed = 10f;
    private float _normalLerpSpeed = 0.05f;
    private float _hitGroundCounter = 0f;
    private float _rotationSpeed = 0.5f;
    void Awake() {
        _player = GameObject.Find("Player");
        _playerController = _player.GetComponent<PlayerController>();
        _cameraController = _player.GetComponentInChildren<CameraController>();
        _target = GameObject.Find("Ground").transform;
    }
    void Update() {
        // Cuando choca contra el suelo desde una larga caída...
        if (_playerController.IsFalling && _playerController.MidAirCounter > 4f) {
            _cameraController.CanMoveCamera = false;
            // Hace que la cámara mire al "suelo", el cual en realidad es un empty gameobject que es hijo de mi player y que está colocado debajo de él...
            var targetRotation = Quaternion.LookRotation(_target.transform.position - transform.position);
            // Suaviza la rotación.
            transform.rotation = Quaternion.Slerp(transform.rotation, targetRotation, _rotationSpeed * Time.deltaTime);
        }
        if (_playerController.MidAirCounter > 4f && _playerController.CC.isGrounded) {
            Camera.main.fieldOfView = Mathf.Lerp(Camera.main.fieldOfView, _hitFOV, _hitLerpSpeed * Time.deltaTime);
            // Después de chocar contra el suelo...
            _hitGroundCounter += 1f * Time.deltaTime;
            if (_hitGroundCounter >= 1.5f && _playerController.CC.isGrounded) {
                Camera.main.fieldOfView = Mathf.Lerp(Camera.main.fieldOfView, _normalFOV, _normalLerpSpeed * Time.deltaTime);
                _cameraController.CanMoveCamera = true;
                _hitGroundCounter = 0f;
                _playerController.MidAirCounter = 0f;
            }
        }
    }
}

 
Ahí está,
espero que alguien me ayude a levantarme de esta caída.
Lol.
 
Gracias de antemano.

Hola!!!
 
La verdad que me parece un error minimo.
 
Pero lo que podrias hacer es colocar una direccion concreta de la camara, osea colocar que cuando aterrize (despues de la linea que pueda mover la camara) que vuelva a rotar pero hacia el frente y que quede recta la camara.
 
Es decir, haces que la camara rote 90 grados en X por ejemplo para que quede alfrente, lo mismo que cuando ve al piso pero viendo hacia el frente.
 
Espero que te ayude.
 
Chau.

Buenas, se te a ocurrido guardar el transform.forward de la cámara justo antes de que la vuelvas loca y restaurarlo al pisar el suelo.

Es que creo que ese no es el problema, el lo que dice es que la camara vuelve al ultimo lado-rotacion que el usuario estaba haciendo en ese momento.
 
Osea que si estaba viendo hacia la derecha cuando recupera el control vuelve a ver a la derecha.
 
En todo caso podria guardar un forward de la camara cada 30 minutos o lo que dices tu.

Hola 

Gracias a ambos por responder.
 
 
 
He probado siguiendo vuestros consejos,

pero me sigue ocurriendo el mismo problema :(
 

Cita de: UnityDevelopersXD date=1477265647Es que creo que ese no es el problema, el lo que dice es que la camara vuelve al ultimo lado-rotacion que el usuario estaba haciendo en ese momento.
   
   
      Osea que si estaba viendo hacia la derecha cuando recupera el control vuelve a ver a la derecha.
   
   
      En todo caso podria guardar un forward de la camara cada 30 minutos o lo que dices tu.
   

Sí, es exactamente eso lo que ocurre con la cámara.

Nuevamente, gracias por vuestras respuestas.

Y el script CameraController???,creo que ahi puede estar el problema,cuando haces el _cameraController.CanMove = true; supongo que ganara el control de la camara ese script y algo hace que se vaya a otra posicion.Pegalo por aqui que lo veamos.

Aquí está el script que de la cámara:
 
 
 

using UnityEngine;
using System.Collections;
[DisallowMultipleComponent]
public class CameraController : MonoBehaviour {
    private GameObject _player;
    private PlayerController _playerController;
    private float _xSensitivity;
    private float _ySensitivity;
    private float _originalSensitivity = 100f;
  
    private float _lookSmooth = 4f;
    private float _lookSmoothInMidAir = 25f;
    private float _xRot;
    private float _yRot;
    private float _currentXRot;
    private float _currentYRot;
    private float _xRotSpeed;
    private float _yRotSpeed;
    private bool _canMoveCamera = true;
    public bool CanMoveCamera {
        get { return _canMoveCamera; }
        set { _canMoveCamera = value; }
    }
    void Awake() {
        _player = GameObject.Find("Player");
        _playerController = _player.GetComponent<PlayerController>();
    }
    void Start() {
        _player = transform.parent.gameObject;
        _xSensitivity = _originalSensitivity;
        _ySensitivity = _originalSensitivity;
    }
    void Update() {
        MouseMovement();
    }
    public void MouseMovement() {
        if (_canMoveCamera) {
            _xRot -= Input.GetAxis("Mouse Y") * _xSensitivity * Time.deltaTime;
            _yRot += Input.GetAxis("Mouse X") * _ySensitivity * Time.deltaTime;
            _xRot = Mathf.Clamp(_xRot, -70f, 70f);
            
            // MidAirCounter es simplemente un contador que va aumentado +1 por segundo
            // cada vez que el jugador está cayendo. Lo uso como si fuera una especie medidor de alturas.
            if (_playerController.IsFalling && (_playerController.MidAirCounter > 1f)) {
              
                // Disminuye la sensibilidad mientras se está cayendo para dar cierta sensación.
                _xSensitivity = Mathf.Lerp(_xSensitivity, 35f, 5f * Time.deltaTime);
                _ySensitivity = Mathf.Lerp(_ySensitivity, 45f, 5f * Time.deltaTime);
                
                // Exagera el SmoothDamp mientras está cayendo para dar también cierta sensación o efecto.
                _currentXRot = Mathf.SmoothDamp(_currentXRot, _xRot, ref _xRotSpeed, _lookSmoothInMidAir * Time.deltaTime);
                _currentYRot = Mathf.SmoothDamp(_currentYRot, _yRot, ref _yRotSpeed, _lookSmoothInMidAir * Time.deltaTime);
                transform.rotation = Quaternion.Euler(_currentXRot, _currentYRot, 0f);
                _player.transform.rotation = Quaternion.Euler(0f, _currentYRot, 0f);
            } else {
                // "Resetea" el SmoothDamp...
                _currentXRot = Mathf.SmoothDamp(_currentXRot, _xRot, ref _xRotSpeed, _lookSmooth * Time.deltaTime);
                _currentYRot = Mathf.SmoothDamp(_currentYRot, _yRot, ref _yRotSpeed, _lookSmooth * Time.deltaTime);
                transform.rotation = Quaternion.Euler(_currentXRot, _currentYRot, 0f);
                _player.transform.rotation = Quaternion.Euler(0f, _currentYRot, 0f);
            }
          
            // Resetea la sensibilidad a su valor original siempre que toque el suelo.
            if (_playerController.CC.isGrounded) {
                _xSensitivity = _originalSensitivity;
                _ySensitivity = _originalSensitivity;
            }
          
            // Disminuye la sensibilidad, pero solamente al inicio del salto, para tratar evitar 360 quick scopes.
            if (_playerController.IsJumping && !_playerController.IsFalling) {
                _xSensitivity = Mathf.Lerp(_xSensitivity, 50f, 10f * Time.deltaTime);
                _ySensitivity = Mathf.Lerp(_ySensitivity, 50f, 10f * Time.deltaTime);
            }
        }
    }
}

 
 
 
Si ves algo raro, por favor dilo.

Pues asi en un vistazo rapido me parece que va ser por _currentXRot y el _currentYRot,cuando haces en el primer script _cameraController.CanMoveCamera = false; los currentRot dejan de actualizarse en el segundo script y cuando vuelves hacer _cameraController.CanMoveCamera = true; pues empiezan desde la ultima vez que los actualizaste,que es antes de caer.
 
Tienes dos opciones, o en el segundo script le metes un else para que cuando _camMoveCamera sea false siga actualizando los currentRot, o cuando haces _cameraController.CanMoveCamera = true en el segundo script actualizas los valores de los currentRot del primer script.

Cita de: hammer date=1477306678Pues asi en un vistazo rapido me parece que va ser por _currentXRot y el _currentYRot,cuando haces en el primer script _cameraController.CanMoveCamera = false; los currentRot dejan de actualizarse en el segundo script y cuando vuelves hacer _cameraController.CanMoveCamera = true; pues empiezan desde la ultima vez que los actualizaste,que es antes de caer.
   
   
      Tienes dos opciones, o en el segundo script le metes un else para que cuando _camMoveCamera sea false siga actualizando los currentRot, o cuando haces _cameraController.CanMoveCamera = true en el segundo script actualizas los valores de los currentRot del primer script.
   

Lo hice pero aún sigue igual.

Ya no se me ocurre qué hacer :(

else if(!_canMoveCamera){
      
      currentXRot = transform.eulerAngles.x;
      currentYRot = transform.eulerAngles.y;
}

 
haciendo esto no te funciona??? te sigue pasando lo mismo o algo diferente??? toy bastante convencido de que el problema es el que te digo,que los currentRot no se actualizan y cuando vuelves a darles el control pues empiezan desde la ultima posicion actualizada.
 
Si sigues sin conseguirlo podrias montar un prefab unitypackage con los scripts en una capsula,no hace falta el modelo,lo justo  para que le hechemos un ojo
 
Saludos!!

Lo que dice Null y hammer tiene mucho sentido, algo debes estar haciendo mal porque parece que asi funciona bastante bien.

Sí, es 100% probable que lo haya hecho mal.
 
A ver, esto fue lo que hice en el primer script siguiendo 

los consejos de esr y UnityDevelopersXD:
 

using UnityEngine;
using System.Collections;
[DisallowMultipleComponent]
public class CameraHitGround : MonoBehaviour {
    private GameObject _player;
    private PlayerController _playerController = null;
    private CameraController _cameraController = null;
  
    private Transform _target;
  
    private float _hitFOV = 20f;
    private float _normalFOV = 72f;
    private float _hitLerpSpeed = 10f;
    private float _normalLerpSpeed = 0.05f;
    private float _hitGroundCounter = 0f;
    private float _rotationSpeed = 0.5f;
    private Vector3 _cameraRot;
    void Awake() {
        _player = GameObject.Find("Player");
        _playerController = _player.GetComponent<PlayerController>();
        _cameraController = _player.GetComponentInChildren<CameraController>();
        _target = GameObject.Find("Ground").transform;
    }
    void Update() {
        // Cuando choca contra el suelo desde una larga caída...
        if (_playerController.IsFalling && _playerController.MidAirCounter > 4f) {
            _cameraController.CanMoveCamera = false;
            // Hace que la cámara mire al "suelo", el cual en realidad es un empty gameobject que es hijo de mi player y que está colocado debajo de él...
            var targetRotation = Quaternion.LookRotation(_target.transform.position - transform.position);
            // Suaviza la rotación.
            transform.rotation = Quaternion.Slerp(transform.rotation, targetRotation, _rotationSpeed * Time.deltaTime);
          
            // Guardo el transform.forward de la cámara después de que haya rotado sola por completo hacia el suelo.
            _cameraRot = Camera.main.transform.forward; // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
        }
        if (_playerController.MidAirCounter > 4f && _playerController.CC.isGrounded) {
            Camera.main.fieldOfView = Mathf.Lerp(Camera.main.fieldOfView, _hitFOV, _hitLerpSpeed * Time.deltaTime);
            // Después de chocar contra el suelo...
            _hitGroundCounter += 1f * Time.deltaTime;
            if (_hitGroundCounter >= 1.5f && _playerController.CC.isGrounded) {
              
                // Restauro de nuevo el transform.forward al chocar contra el suelo.
                Camera.main.transform.forward = _cameraRot; // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
              
                Camera.main.fieldOfView = Mathf.Lerp(Camera.main.fieldOfView, _normalFOV, _normalLerpSpeed * Time.deltaTime);
                _cameraController.CanMoveCamera = true;
                _hitGroundCounter = 0f;
                _playerController.MidAirCounter = 0f;
            }
        }
    }
}

 
_________________________________________________________________________________________________
 
Y esto fue lo que hice en el segundo script,

eligiendo la primera opción que me propuso hammer

de añadirle un else a "if (_canMoveCamera)":
 

using UnityEngine;
using System.Collections;
[DisallowMultipleComponent]
public class CameraController : MonoBehaviour {
    private GameObject _player;
    private PlayerController _playerController;
    private float _xSensitivity;
    private float _ySensitivity;
    private float _originalSensitivity = 100f;
  
    private float _lookSmooth = 4f;
    private float _lookSmoothInMidAir = 25f;
    private float _xRot;
    private float _yRot;
    private float _currentXRot;
    private float _currentYRot;
    private float _xRotSpeed;
    private float _yRotSpeed;
    private bool _canMoveCamera = true;
    public bool CanMoveCamera {
        get { return _canMoveCamera; }
        set { _canMoveCamera = value; }
    }
    void Awake() {
        _player = GameObject.Find("Player");
        _playerController = _player.GetComponent<PlayerController>();
    }
    void Start() {
        _player = transform.parent.gameObject;
        _xSensitivity = _originalSensitivity;
        _ySensitivity = _originalSensitivity;
    }
    void Update() {
        MouseMovement();
    }
    public void MouseMovement() {
        if (_canMoveCamera) {
            _xRot -= Input.GetAxis("Mouse Y") * _xSensitivity * Time.deltaTime;
            _yRot += Input.GetAxis("Mouse X") * _ySensitivity * Time.deltaTime;
            _xRot = Mathf.Clamp(_xRot, -70f, 70f);
            
            // MidAirCounter es simplemente un contador que va aumentado +1 por segundo
            // cada vez que el jugador está cayendo. Lo uso como si fuera una especie medidor de alturas.
            if (_playerController.IsFalling && (_playerController.MidAirCounter > 1f)) {
              
                // Disminuye la sensibilidad mientras se está cayendo para dar cierta sensación.
                _xSensitivity = Mathf.Lerp(_xSensitivity, 35f, 5f * Time.deltaTime);
                _ySensitivity = Mathf.Lerp(_ySensitivity, 45f, 5f * Time.deltaTime);
                
                // Exagera el SmoothDamp mientras está cayendo para dar también cierta sensación o efecto.
                _currentXRot = Mathf.SmoothDamp(_currentXRot, _xRot, ref _xRotSpeed, _lookSmoothInMidAir * Time.deltaTime);
                _currentYRot = Mathf.SmoothDamp(_currentYRot, _yRot, ref _yRotSpeed, _lookSmoothInMidAir * Time.deltaTime);
                transform.rotation = Quaternion.Euler(_currentXRot, _currentYRot, 0f);
                _player.transform.rotation = Quaternion.Euler(0f, _currentYRot, 0f);
            } else {
                // "Resetea" el SmoothDamp...
                _currentXRot = Mathf.SmoothDamp(_currentXRot, _xRot, ref _xRotSpeed, _lookSmooth * Time.deltaTime);
                _currentYRot = Mathf.SmoothDamp(_currentYRot, _yRot, ref _yRotSpeed, _lookSmooth * Time.deltaTime);
                transform.rotation = Quaternion.Euler(_currentXRot, _currentYRot, 0f);
                _player.transform.rotation = Quaternion.Euler(0f, _currentYRot, 0f);
            }
          
            // Resetea la sensibilidad a su valor original siempre que toque el suelo.
            if (_playerController.CC.isGrounded) {
                _xSensitivity = _originalSensitivity;
                _ySensitivity = _originalSensitivity;
            }
          
            // Disminuye la sensibilidad, pero solamente al inicio del salto, para tratar evitar 360 quick scopes.
            if (_playerController.IsJumping && !_playerController.IsFalling) {
                _xSensitivity = Mathf.Lerp(_xSensitivity, 50f, 10f * Time.deltaTime);
                _ySensitivity = Mathf.Lerp(_ySensitivity, 50f, 10f * Time.deltaTime);
            }
        } else { // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
            _currentXRot = transform.eulerAngles.x;
            _currentYRot = transform.eulerAngles.y;
        }
    }
}

 
 
 
Respondiendo a la respuesta de hammer de que si me pasa algo diferente o no:

No, me sigue dando el mismo resultado, es decir, no cambia nada, el problema sigue intacto.
 
También decir que probé la segunda opción, y tampoco me funcionó.
 
 
 
 
 
Pero vamos, que lo más seguro es eso, que me haya confundido con algo.

En todo caso perdónenme lo noob que hay en mí a veces.
 
Si veis mi error, por favor decidme, o si no pues subiré mi cápsula con los scripts

si gustáis de revisarlo a fondo.
 


Muchas. muchas gracias de nuevo por la ayuda :)

Pues no lo veo xD xD, si montas una capsulilla con los scripts mejor,por que asi "a pelo" no lo veo,yo por lo menos xD xD
 
:)

La verdad que no me pondre a revisar codigo por codigo aqui XD pero a simple vista se ve bien.
 
Si, sube la capsula con todo y scripts para revisarlo mejor.

Jajaja bueno.
 
Aquí está el enlace (https://mega.nz/#!yctxTIYa!fZ1yauoz30Bzs2pY3iINWQktJzb4SEUxqGy-39BJ8w4).

Por comodidad, poned el prefab "EditorStuff" también en la jerarquía.

Contiene un pequeño script que hice para hacer las cosas un poco fáciles.
 


Mientras ejecutáis el juego, si hacéis clic derecho, se pausa el juego,

y podéis mover el ratón libremente por Unity.

Y si hacéis clic izquierdo en la ventana Game volvéis a quitar la pausa.
 
Poned una plataforma grande que sirva de suelo, y luego poned otra

plataforma más pequeña bastante alta con el player encima de ella,

y ahora sí os podéis tirar xdd
 
Aclarar que si la cámara no os mira hacia el suelo automáticamente,

es porque la plataforma no está lo suficientemente alta.
 
Con la tecla R podéis resetear la posición del player, para cuando os tiréis

y lleguéis al suelo.
 
 
 
Probad a hacer lo que expliqué.

Tiraos y mirad hacia arriba todo el rato,

o cualquier otra dirección.

Creo que el enlace esta mal.
 
Cuando lo abro me salen algunos errores y el prefab del jugador no esta completo.
 
Intenta resubirlo denuevo.

Bueno a mi no me salian errores,no se veia el mesh pero por lo demas bien, es lo que te decia XD,pero tambien tienes que actualizar el _xRot y el _yRot,obviamente si hay que actualizar uno havia que actulizar el target tambien XD :P,no se como no cai,se me paso,muy pez por mi parte XD xD.
 
total,quedaria asi
 

else { // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
            _currentXRot = transform.eulerAngles.x;
            _currentYRot = transform.eulerAngles.y;
      _xRot = transform.eulerAngles.x;
      _yRot = transform.eulerAngles.y;
        }

 
 

Funciona!!!
 
Muchas gracias, de verdad.

No sé cuánto os debo pero me habéis solucionado

la vida.
 

Cita de: UnityDevelopersXD date=1477418403Creo que el enlace esta mal.
   
   
      Cuando lo abro me salen algunos errores y el prefab del jugador no esta completo.
   
   
      Intenta resubirlo denuevo.
   

Qué raro, lo he revisado y debería estar todo bien!

A hammer le funciona!
 

Cita de: hammer date=1477438469Bueno a mi no me salian errores,no se veia el mesh pero por lo demas bien
   
   
       
   

No, no, es que no tiene mesh!

De momento es solo una cápsula.

Quizás fue un fallo no decir que era un firstperson

sin modelo ni nada jajajaja
 
Bueno, ahora sí,

mil gracias, caballeros 

Que raro XD
 
Bueno que bien que hallas solucionado el problema, le debes dinero a hammer XD
 
Chau.

Con una cervecita me conformo :D :D
 
Saludos!