Hola! Cómo están?


Tengo un pequeño problema con un script que hice.

Lo único que hace es limitar el ángulo de rotación de la cámara en Y, pero única y exclusivamente al saltar.

Funciona genial, pero he notado que al pasar por el 'grado' 0 (ó -0), hace un giro muy extraño y repentino.


He exagerado un poco el salto del player para hacer un corto de ejemplo.
El cubo verde representa la rotación 0:
https://i.gyazo.com/06151e526fa4f9e3e0ecc557eb60abae.mp4


Nótese como el primer salto es correcto, funciona bien. Pero el segundo... al pasar por el 0 (cubo verde) hace un giro extraño al momento de volver a saltar.

Lo que acaban de ver en ese vídeo también ocurre si giro en la dirección contraria a las agujas del reloj.
 
El mencionado script está colocado en el player y así es como se lee:
 

if (!controller.isGrounded)
{
  cameraController.Yaw = Mathf.Clamp(cameraController.Yaw, transform.localEulerAngles.y - 20, transform.localEulerAngles.y + 20);
}

 
Ese es todo el código que hice al respecto para lograr esa funcionalidad, así que me imagino que es él quien está mal.

A mi corto modo de ver, es como que al estar en números positivos y al pasar a negativos (y viceversa), es cuando se vuelve loco.


No sé cómo podría solucionarlo y por eso hago este post

Muchas gracias por su amabilidad.

Hola, cómo están?


Por casualidad alguien sabría decirme por qué ocurre ésto entre mis objetos 3D, en este caso la carretera?
Nótese la raya negra que hay casi en el centro de la imagen:



Estoy siguiendo el diseño modular para crear cosas como la carretera y los edificios del juego...

pero si se va a ver ese extraño borde oscuro cada vez, pues como que me preocupa.


Alguien sabe?

No sé ha pasado... me puse a crear unas cuantas animaciones, e iba todo correctamente...

Pero después de un rato sin tener ningún problema, pasó que intenté animar las rotaciones de un objeto, pero me ocurrió ESTO...

Por si no se entiende el enlace:

* Lo que hice fue rotar el objeto SOLO 90º aproximadamente, para que se añadiera un keyframe, pero como veis al pulsar el botón Play la rotación se vuelve completamente loca.


No sé cómo solucionarlo! Cerré Unity, lo volví a abrir, y nada. Reinicié PC, nada. Reinstalé Unity al completo, y tampoco...

Probé a animar las rotaciones de un cubo en otro proyecto totalmente nuevo, y allí sí que funcionaba bien!

Una solución entonces podría ser migrar el proyecto entero a uno nuevo, pero es demasiado grande actualmente, así que mejor dejemos eso como último recurso.


Mencionar que yo no toqué nada, casi podría decir que ocurrió al azar. Es primera vez que me pasa.

Ojalá alguien me pueda dar soluciones alternativas.

Muchas gracias :'b

Supongamos que tengo el siguiente código que controla la variable vida de un enemigo:
 

public class EnemyHealth : MonoBehaviour {
     float currentHealth;
float amount      = .5f;
float maxHealth = 100;
  
public float CurrentHealth { get { return currentHealth; } set { currentHealth = value; } }
  
void Update() {
        if (currentHealth <   maxHealth) currentHealth += Time.deltaTime * amount;
        if (currentHealth >= maxHealth) currentHealth   = maxHealth;
        if (currentHealth <= 0f)               currentHealth   = 0f;
}
}

 
Y también tengo este CustomEditor:
 

[CustomEditor(typeof(EnemyHealth))]
public class EnemyHealthEditor : Editor {
     
     public override void OnInspectorGUI() {
        
         EnemyHealth enemyHealth  = (EnemyHealth)target;
         enemyHealth.CurrentHealth = EditorGUILayout.FloatField("Health", enemyHealth.CurrentHealth); 
    }
}

 
El problema que tengo es que la variable (en el inspector) no se actualiza cuando es < maxHealth, tal como indica su código... Si por ejemplo le pongo el valor 55 en el inspector, vuelve a 0, sin actualizarse.

Antes de haber escrito el CustomEditor, simplemente tenía la variable en public y se actualizaba bien.
Peor aún: He notado que si pongo el mouse encima del inspector (sin hacer clicks de ningún tipo), y lo muevo hacia otra ventana de Unity, sí se actualiza... (?)
 
>>> Vídeo de muestra (nótese que no estoy haciendo dragging)


Cómo lo soluciono? 

Aloha.
 
Estaba trasteando con un singleton, probando cosas, etc...

y resulta que declaré un evento dentro del singleton, al cual quiero llamar desde otro script, pero me da un error el cual antes no tenía.


Singleton!:
 

public class GameManager {
     #region "Singleton"
     static GameManager instance;
     public static GameManager Instance {
         get {
             if (instance == null) instance = new GameManager();
             return instance;
         }
     }
    #endregion
    
    public event Action OnPlayerGrounded; // El evento.
    
    CharacterController cc;
    public CharacterController CC => cc;
    void Awake() {
        cc = GameObject.FindGameObjectWithTag("Player").GetComponent<CharacterController>(); 
    }
}

 
 
 
Script desde el que intento llamar al evento:
 

public class PlayerController {
    void Update() {
        if (GameManager.Instance.CC.isGrounded)
            GameManager.Instance.OnPlayerGrounded?.Invoke(); // Aquí es donde obtengo el error.
    }
}

 
El error que me da es el Assets/Scripts/Player/PlayerController.cs(23,70): error CS0070: The event `GameManager.OnPlayerGrounded' can only appear on the left hand side of += or -= when used outside of the type `GameManager'...

Antes simplemente tenía el evento declarado dentro de PlayerController y simplemente decía:
 

if (cc.isGrounded) OnPlayerGrounded();

 
y funcionaba... pero ahora me dio por tener un poco más de orden y usar managers

Qué solución puede haber en este caso? Mil y una gracias.

Holas.
Resulta que tengo un script que hace que al tener un objeto seleccionado en Editor Mode y usar Ctrl+F, posiciona a dicho objeto a ras de suelo, o sobre cualquier otro objeto que éste tenga debajo, mediante raycast.
Es más que nada por comodidad, para hacerme la vida más fácil con algunos gameobjects que quedan flotando y que me dan pereza bajarlos manualmente con los gizmos, jeje.
 
Para ello uso 2 scripts, pero el problema es que para que funcione, el gameobject debe tener el script "PlaceToGround". Y pues tendría que añadir ese script a todos los objetos de la escena.
Entonces, mi plan era simplemente añadir el script al objeto que tenga seleccionado, mediante código, para después de de-seleccionarlo, quitárselo y aquí no pasó nada.
Todo funciona genial, pero pues lo de añadir el script al seleccionado no.
Alguna sugerencia? 
 
 
 
Este es el script que ejecuta el atajo de teclado:
 

using UnityEngine;
using Unit***itor;
public class Pereza : MonoBehaviour {
  [MenuItem("Comandos/A ras de suelo %f")]
  private static void SpecialCmd() {
    if (PlaceToGround.CanLand) {
      var offset = new Vector3(0f, -.2f, 0f);
      var selected = Selection.activeGameObject.transform;
      
      selected.SetPositionAndRotation(PlaceToGround.hit.point + offset, selected.transform.rotation);
    }
  }
}

 
 
 
Y este el que usa raycast y el cual deben tener los objetos:
 

using UnityEngine;
[ExecuteInEditMode]
public class PlaceToGround : MonoBehaviour {
  private static RaycastHit m_hit;
  private float m_maxDist = 100;
  private static bool m_canLand = false;
  
  public static RaycastHit Hit { get { return m_hit; } }
  public static bool CanLand { get { return m_canLand; } }
  
  private void Update() {
    Ray ray = new Ray(transform.position, Vector3.down * m_maxDist);
    
    if (Physics.Raycast(ray, out m_hit, m_maxDist)) {
      Debug.DrawRay(ray.origin, ray.direction * m_hit.distance, Color.red);
      m_canLand = true;
    } else {
      m_canLand = false;
    }
  }
}

 
 

Holas.
 
Tengo un problema
Supongamos que en la ventana Scene ajusto la rotación del player, de modo que cuando se inicie el juego, él comience mirando hacia 'x' dirección...
Bueno, pues resulta que al iniciar el juego, el jugador ignora la rotación que yo le asigné y en su lugar se orienta hacia el eje Z... siempre.
Mirad esta pequeña secuencia de ejemplo.
 
Este es el script del jugador:
 

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class PlayerMovement : MonoBehaviour {
    private static CharacterController _cc;
    private static float _currentSpeed = 2f;
    private static bool _canMove = true;
    public static CharacterController CC { get { return _cc; } set { _cc = value; } }
    private void Awake() {
        _cc = GetComponent<CharacterController>();
    }
    private void Update() {
        float hAxis = Input.GetAxis("Horizontal") * _currentSpeed;
        float vAxis = Input.GetAxis("Vertical") * _currentSpeed;
        Vector3 movement = new Vector3(hAxis, PlayerJump.Gravity, vAxis);
        movement = transform.rotation * movement;
        if (_canMove)
            _cc.Move(movement * Time.deltaTime);
    }
}

 
A ver si alguien me echa el guante.
Muchas gracias, de verdad (:

Hola, qué tal?
 
Tengo un problema con los animator controller, y es que tengo a un player (el cual es un sprite) que tiene que evolucionar, y para eso he creado varios animator controller y se los voy cambiando de la siguiente manera,

según los puntos que tiene para "evolucionar" :
 

private Animator _anim;
public RunTimeAnimatorController _stage2Controller;
public RunTimeAnimatorController _stage3Controller;
public RunTimeAnimatorController _stage4Controller;
private void Awake() {
  _anim = GetComponent<Animator>();
}
private void Update() {
  if (/* Puntos de evolución >= 10 */) {
    _anim.runtimeAnimatorController = _stage2Controller;
  }
  if (/* Puntos de evolución >= 20 */) {
    _anim.runtimeAnimatorController = _stage3Controller;
  }
  if (/* Puntos de evolución >= 30 */) {
    _anim.runtimeAnimatorController = _stage4Controller;
  }
}

 
Y bueno, al pasar al stage 2, evoluciona correctamente y las animaciones se reproducen bien...

Pero es a partir del stage 2 que al volver a evolucionar, lo hace bien, PERO sin reproducir las animaciones.
 
Ejemplo


Qué hago mal?

Gracias 

Hola!


Tengo una duda rápida...

Imaginemos que tengo un collider con el isTrigger activo, y que se lo he puesto a un GameObject en la cabeza.

Pero luego le pongo al mismo GameObject otro collider, también con el isTrigger activo, pero esta vez en la pierna...
 
Bueno, aquí empieza mi duda...

Dentro del OnTriggerEnter... cómo hago referencia al trigger de la cabeza sin que el de la pierna se vea afectado?

Cómo los distingo?
 
Thank you <3
 
 

Hola.

Tengo este script:
 

using UnityEngine;
public class PlaceObj : MonoBehaviour {
  [SerializeField]
  private GameObject _obj;
  
  private void FixedUpdate() {
    RaycastHit2D hit2D = Physics2D(transform.position, Camera.main.ScreenToWorldPoint(Input.mousePosition));
    
    if (Input.GetMouseButtonDown()) {
      Instantiate(_obj, hit2D.transform.position, Quaternion.identity);
    }
    Debug.DrawLine(transform.position, hit2D.transform.position, Color.magenta);
  }
}

 
y lo que buscaba era dibujar un ray desde la posición de la cámara, hasta el punto exacto del ratón.

Pero el problema es que el ray no se mueve para nada cuando muevo el ratón, y todo el rato me instancia el _obj en la misma posición al hacer clic.


Qué no estoy entendiendo?

Hey!
 
Estoy tratando de hacer que un cubo detecte a otros cubos que tiene alrededor,

y lo único que hago es colocar un pequeño collider en solo cuatro de las caras del cubo, así:

 
Y en un script tengo una variable que me lleva la cuenta de los cubos adyacentes cada vez que se hace OnTriggerEnter/Exit.
 

private int _neighbors;
private void OnTriggerEnter(Collider other) {
  _neighbors++;
}
private void OnTriggerExit(Collider other) {
  _neighbors--;
}

 
Es tontamente simple, y funciona bien.

El problema es que llevo toda la noche, ya casi toda la mañana, probando mil combinaciones para detectar los cubos que estén en diagonal !!!

 


Sé que también podría usar Raycast en las cuatro esquinas del cubo, pero no me sirve, porque el conteo de los cubos se me vuelve loco... Y no sé como posicionar los triggers en las esquinas

de manera que no estorben al conteo tampoco...
 
Por favor, que alguien me ilumine... De qué manera detecto los cubos en diagonal?

Hola 
 
Resulta que quise hacer una build de mi juego para probarlo ya en sí, a ver cómo se veían ciertas cosas y etc,

pero me di cuenta de que si pongo la calidad en "Fastest" o también en "Fast" el movimiento del ratón se vuelve muy, muy lento.

Tanto así que tienes que mover toda la mano por la mesa para tan si quiera rotar unos pocos grados.
 
Sin embargo, en todas las demás calidades el ratón se mueve correctamente.

No he tocado ninguna opción gráfica, todas están por defecto.
 
Aún así, revisándolas dentro de Unity en la ventana Quality, veo que tanto Fastest como Fast tienen vSync en Off, y todas las demás en On,

así que pensé que ese puede ser el problema.
 
 
 
Aparte de activar la vSync en ambas configuraciones gráficas... debe de haber otra cosa que pueda hacer...

Sería terrible si alguien lo quiere jugar sin vSync y el ratón es una roca.
 
El script de mi cámara, por si dudas:
 

using UnityEngine;
using System.Collections;
[DisallowMultipleComponent]
public class CameraController : MonoBehaviour {
    /* VARIABLES */
    private GameObject _player;
    private PlayerController _pc = null;
    private float _xSensitivity;
    private float _ySensitivity;
    private float _originalSensitivity = 100f;
    private float _normalSmooth = 4f;
    private float _midairSmooth = 30f;
    private float _xRot;
    private float _yRot;
    private float _currentXRot;
    private float _currentYRot;
    private float _xRotSpeed;
    private float _yRotSpeed;
    private bool _canMoveCamera = true;
    /* PROPIEDADES */
    public bool CanMoveCamera {
        get { return _canMoveCamera; }
        set { _canMoveCamera = value; }
    }
    /* SISTEMA */
    void Awake() {
        _player = GameObject.FindGameObjectWithTag("Player");
        _pc = _player.GetComponent<PlayerController>();
    }
    void Start() {
        _player = transform.parent.gameObject;
        _xSensitivity = _originalSensitivity;
        _ySensitivity = _originalSensitivity;
    }
    void Update() {
        MouseMovement();
    }
    /* MIS MÉTODOS */
    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);
            // Decrementa la sensibilidad y añade SmoothDamp cuando el player esté cayendo desde x altura.
            if (_pc.IsFalling && (_pc.HeightCounter > _pc.MinHeightCounter)) {
                XYSensitivitiesTo(95f, 95f, 5f);
                SmoothDampVelocityTo(_midairSmooth);
                SetRotations();
            } else { // SmoothDamp vuelve a la normalidad.
                SmoothDampVelocityTo(_normalSmooth);
                SetRotations();
            }
            // Decrementa la sensibilidad siempre que el player esté saltando pero aún no cayendo.
            if (_pc.IsJumping && !_pc.IsFalling) {
                XYSensitivitiesTo(50f, 50f, 10f);
            }
            // Resetea la sensibilidad siempre que el player toque suelo.
            if (_pc.CC.isGrounded) {
                _xSensitivity = _originalSensitivity;
                _ySensitivity = _originalSensitivity;
            }
            if (_pc.IsRunning) {
                _ySensitivity = 70f;
            }
        } else { // Sigue actualizando las rotaciones a pesar de que no pueda mover la cámara.
            _currentXRot = transform.eulerAngles.x;
            _currentYRot = transform.eulerAngles.y;
            _xRot = transform.eulerAngles.x;
            _yRot = transform.eulerAngles.y;
        }
    }
    private void SetRotations() {
        transform.rotation = Quaternion.Euler(_currentXRot, _currentYRot, 0f);
        _player.transform.rotation = Quaternion.Euler(0f, _currentYRot, 0f);
    }
    private void XYSensitivitiesTo(float ToXSensitivity, float ToYSensitivity, float lerpVelocity) {
        _xSensitivity = Mathf.Lerp(_xSensitivity, ToXSensitivity, lerpVelocity * Time.deltaTime);
        _ySensitivity = Mathf.Lerp(_ySensitivity, ToYSensitivity, lerpVelocity * Time.deltaTime);
    }
    private void SmoothDampVelocityTo(float smoothAmount) {
        _currentXRot = Mathf.SmoothDamp(_currentXRot, _xRot, ref _xRotSpeed, smoothAmount * Time.deltaTime);
        _currentYRot = Mathf.SmoothDamp(_currentYRot, _yRot, ref _yRotSpeed, smoothAmount * Time.deltaTime);
    }
}

 
 

Duda rápida...
 
Qué es más conveniente? 

Usar:
 

if (Input.GetKey(KeyCode.A)) {
  
}

 
o usar:
 

if (Input.GetKey("A")) {
}

 
?

Existe alguna diferencia más allá de la sintaxis?

Por cierto, hola!

Hola 
 
Tuve dudas de si ésto debe ir aquí o en otra categoría, porque se mezclan un poco dos temas...
 
Pero bueno, resulta que estaba revisando en la documentación de Unity, y me encontré con Terrain.SetNeighbors, y se me abrieron los ojos como platos. Total que buscando por ahí encontré este vídeo, y me guié en él. 
 
Pero resulta que haga lo que haga, por mucho que revise mil veces que seleccioné bien los 2 terrenos en World Machine, y por mucho que revise que las posiciones de ambos terrenos en Unity está bien, los dos terrenos siguen sin encajar. Realmente digamos sí lo hacen, pero dan un error visual en el borde en el que supuestamente deberían estar "juntándose":
 

 
Ya sé que no encajan correctamente por culpa del desnivel de ambos terrenos, y eso es precisamente lo que me quiebra la cabeza, porque os juro que las posiciones están bien, las dimensiones de los terrenos son las mismas, y todo bien!!
 
El vídeo es de hace unos 3 años, y no sé si han cambiado algunas cosas tanto en Unity como en World Machine.
 
Alguien sabe?

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.

Aloha.
 
Usando un CharacterController cómo puedo comprobar sí

el player está cayendo?


Si la Y es negativa, por ejemplo?

Aunque ahora mientras escribo esto pienso que quizás eso podría dar bastantes problemas.
 
Conocéis alguna otra forma de hacerlo?

Se agradecen las respuestas!

Alguien tiene alguna idea o referencia de cómo podría programar
el movimiento de algo que se mueve bajo el mar o por el aire?
Pongamos como ejemplo un tiburón esta vez.
Ya que estuve pensando y la verdad el NavMeshAgent creo que no me sirve,
porque solo actúa por una malla "suelo" por la cual transitar, es decir, que el tiburón
solo vendría a por mí si estoy al mismo nivel que él...
 
Algún pequeño consejo sobre esto?
 
 

Me ocurre que al asignarle el height map

a mi modelo, veo que ocurren cosas extrañas en algunos bordes.
 
Como ejemplo tengo este gif

(fíjense el borde que está en la parte derecha):
 
https://i.gyazo.com/a20ae53e34e930f3a0816bad6acd2820.gif
 
 
 
Saqué el height map con xNormal.

Que por cierto, si alguien quiere comprobar (por lo que sea) el height map, aquí lo pongo:
 

 
Así aprovecho para preguntar... Alguien sabe por qué se ven los bordes de mi modelo lowpoly en el height map?

Tengo una texutra de AO la cual puse en el material de mi modelo,

pero resulta que no se ve, y no entiendo porqué.
 
Estuve haciendo pruebas cambiando la iluminación del escenario, pensando que era ese el problema.

También probé volver a crear la textura nuevamente pero con mucha más intensidad a ver si se ve, y nada.

Luego también probé a cambiar en QualitySettings, pensando también que podría ser ese el problema o algo,

pero tampoco.
 
Nada de nada me sirve.

Que por cierto, no solo me pasa en este proyecto, si no también en todos...


En cambio cuando le pongo el NormalMap sí que se ve, e igual con el HeightMap.

La iluminación que estoy usando es Realtime.
 
Qué pasa?

Hi.
 
Tengo hecho el salto de mi player,

pero éste aún tiene control de movimiento estando en el aire,

y la verdad no busco eso.

 
 
Lo que busco en su lugar es que si está caminando en una dirección,

y entonces salta, que no pueda moverse en el aire hacia los lados,

o por lo menos hacer que pueda moverse muy poco, para que el salto

no sea TAN rígido.
 


He probado con poner todo el código que hace que mi player camine

dentro de un "if (isGrounded) ...", pero no me funcionó.
 
 
 
Adiciono las partes del código que uso para hacer

que mi player camine, y salte, aquí abajo.

Estoy usando un CharacterController.
 
Nótese que en este código todavía no intenté corregir dicho problema:
 

    void Caminar()
    {
        float _movVertical = Input.GetAxis("Vertical") * _velocidadActual;
        float _movHorizontal = Input.GetAxis("Horizontal") * _velocidadActual;
        _gravedad += Physics.gravity.y * Time.deltaTime;
        Vector3 _velocidad = new Vector3(_movHorizontal, _gravedad, _movVertical);
        _velocidad = transform.rotation * _velocidad;
        _cc.Move(_velocidad * Time.deltaTime);
    }
    void Saltar()
    {
        if (_cc.isGrounded)
        {
            _estaEnElSuelo = true;
            _puedeSaltar = true;
            _puedeCorrer = true;
        }
        else
        {
            _estaEnElSuelo = false;
            _puedeSaltar = false;
            _puedeCorrer = false;
        }
        if (_puedeSaltar)
        {
            if (Input.GetButtonDown("Jump"))
            {
                _gravedad = _fuerzaSalto;
            }
            else if (!Input.GetButtonDown("Jump"))
            {
                _gravedad = -10f;
            }
        }
    }

 
 
 
Qué puedo hacer para corregir esto?