- Home /
Question by
Reefer · May 14, 2016 at 03:42 PM ·
jumpnavmeshagentjumping
Can't jump with navmeshagent..
Ive been trying to get my player to jump with NavMeshAgent by starting and stopping it at right moment in code, but still no luck after an hour trying to fix it.. If someone could help me out, what I'm missing here?
using UnityEngine;
using m_IEnumerator = System.Collections.IEnumerator;
namespace HuntingGame
{
[RequireComponent( typeof( CameraHeadBob ) )]
[RequireComponent( typeof( FootstepManager ) )]
[RequireComponent( typeof( CharacterController ) )]
public class FirstPersonController : MonoBehaviour
{
// Fields for parameters
[SerializeField]
private bool canWalk = true;
[SerializeField]
private float walkSpeed = 4.25f;
[SerializeField]
private float backwardsSpeed = .6f;
[SerializeField]
private float sidewaysSpeed = .7f;
[SerializeField]
private float inAirSpeed = .35f;
[SerializeField]
private bool canRun = true;
[SerializeField]
private float runSpeed = 8.75f;
[SerializeField]
private string runBtnName = "Run";
[SerializeField]
private bool canCrouch = true;
[SerializeField]
private float crouchSpeed = .45f;
[SerializeField]
private float crouchHeight = 1.25f;
[SerializeField]
private bool canJump = true;
[SerializeField]
private float jumpForce = 5f;
[SerializeField]
private bool canClimb = true;
[SerializeField]
private float climbingSpeed = .8f;
[SerializeField]
private bool useHeadBob = true;
[SerializeField]
private float posForce = .65f;
[SerializeField]
private float tiltForce = .85f;
[SerializeField]
private float gravityMultiplier = 2f;
[SerializeField]
private float fallingDistanceToDamage = 3f;
[SerializeField]
private float fallingDamageMultiplier = 3.5f;
[SerializeField]
private float stepInterval = .5f;
[SerializeField]
private float lookSmooth = .721f;
[SerializeField]
private float maxLookAngleY = 65f;
[SerializeField]
private Vector3 cameraOffset = Vector3.up;
NavMeshAgent navAgent;
public static bool isGrounded { get; private set; }
public static bool isClimbing { get; private set; }
public static bool isMoving { get; private set; }
public static bool isRunning { get; private set; }
public static bool isCrouched { get; private set; }
public static bool isJumping { get; private set; }
public static bool isFalling { get; private set; }
public static RaycastHit floorHit { get { return hitInfo; } }
private static RaycastHit hitInfo;
// Fields for move calculation
private bool prevGrounded, jump, crouching;
private CharacterController m_Controller = null;
private CollisionFlags collisionFlags = CollisionFlags.None;
private Transform m_Transform, cameraTransform;
private Vector3 moveDirection, crouchVelVec;
private float nextStep, nativeCapsuleHeight, crouchVel, fallingStartPos, fallingDist;
private ILadder currentLadder = null;
private IFootstepManager m_FootstepManager = null;
private static FirstPersonController instance = null;
// Fields for look calculation
private float rotationX, rotationY;
private Quaternion nativeRotation = Quaternion.identity;
// Awake
void Awake()
{
navAgent = GetComponent<NavMeshAgent>();
instance = this;
m_Controller = this.GetComponent<CharacterController>();
m_Controller.center = Vector3.up;
nativeCapsuleHeight = m_Controller.height;
m_FootstepManager = this.GetComponent<IFootstepManager>();
}
// Start
void Start()
{
m_Transform = transform;
cameraTransform = PlayerCamera.m_Transform;
nativeRotation = cameraTransform.localRotation;
nativeRotation.eulerAngles = Vector3.up * cameraTransform.localEulerAngles.y;
}
// OnEnable
void OnEnable()
{
isMoving = isGrounded = isClimbing = isCrouched = false;
}
// FixedUpdate
void FixedUpdate()
{
isGrounded = m_Controller.isGrounded;
if( isGrounded )
{
if( isFalling )
{
isFalling = false;
if( fallingDist > fallingDistanceToDamage )
{
int damage = Mathf.RoundToInt( fallingDist * fallingDamageMultiplier );
HudElements.HealthBar.SetDamageTargetPosition( Vector3.zero );
PlayerCharacter.Instance.DecrementHealth( damage );
}
fallingDist = 0f;
}
}
else
{
if( isFalling )
{
fallingDist = fallingStartPos - m_Transform.position.y;
}
else
{
if( !isClimbing )
{
isFalling = true;
fallingStartPos = m_Transform.position.y;
}
}
}
CameraLook();
Movement();
PlayFootStepAudio();
if( !isClimbing && !isGrounded && !isJumping && prevGrounded )
moveDirection.y = 0f;
prevGrounded = isGrounded;
}
// Jump
internal static void Jump()
{
if( isClimbing || instance.crouching || !isGrounded )
return;
if( instance.canJump && instance.canWalk && !instance.jump && !isJumping && !isCrouched )
instance.jump = true;
}
// Crouch
internal static void Crouch()
{
if( !instance.canCrouch || isClimbing || instance.crouching || !isGrounded )
return;
instance.crouching = true;
if( isCrouched )
{
if( Physics.SphereCast( instance.m_Transform.position + Vector3.up * .75f, instance.m_Controller.radius, Vector3.up, out hitInfo, instance.nativeCapsuleHeight * .25f ) )
{
//Debug.Log( "StandUp return" );
instance.crouching = false;
return;
}
//Debug.Log( "StandUp RUN" );
instance.StartCoroutine( instance.StandUp() );
}
else
{
instance.StartCoroutine( instance.SitDown() );
}
}
// Movement
private void Movement()
{
navAgent.Resume();
float horizontal = ASKInputManager.moveHorizontal * Time.timeScale; // move Left/Right
float vertical = ASKInputManager.moveVertical * Time.timeScale; // move Forward/Backward
bool moveForward = ( vertical > 0f );
vertical *= ( moveForward ? 1f : backwardsSpeed );
horizontal *= sidewaysSpeed;
Quaternion screenMovementSpace = Quaternion.Euler( 0f, cameraTransform.eulerAngles.y, 0f );
Vector3 forwardVector = screenMovementSpace * Vector3.forward * vertical;
Vector3 rightVector = screenMovementSpace * Vector3.right * horizontal;
Vector3 moveVector = forwardVector + rightVector;
if( isClimbing )
{
bool lookUp = cameraTransform.forward.y > -.4f;
if( moveForward )
{
forwardVector = currentLadder.m_Transform.up * vertical;
forwardVector *= lookUp ? 1f : -1f;
}
moveVector = forwardVector + rightVector;
if( isGrounded )
{
if( moveForward && !lookUp )
moveVector += screenMovementSpace * Vector3.forward;
}
else
{
if( moveForward && lookUp )
moveVector += screenMovementSpace * Vector3.forward;
}
moveDirection = moveVector * GetSpeed( moveForward );
}
else
{
if( isGrounded )
{
Physics.SphereCast( m_Transform.position + m_Controller.center, m_Controller.radius, Vector3.down, out hitInfo, m_Controller.height * .5f );
moveDirection = moveVector * GetSpeed( moveForward );
moveDirection.y = -10f;
if( jump )
{
m_FootstepManager.PlayJumpingSound( hitInfo );
navAgent.Stop();
isJumping = true;
jump = false;
moveDirection.y = jumpForce;
}
}
else
{
moveDirection += Physics.gravity * gravityMultiplier * Time.fixedDeltaTime;
}
}
if( canWalk )
collisionFlags = m_Controller.Move( moveDirection * Time.fixedDeltaTime );
bool accelerated = ( m_Controller.velocity.magnitude > .01f );
isMoving = isClimbing ? accelerated : isGrounded && accelerated;
}
// Get Speed
private float GetSpeed( bool inForward )
{
bool runReady = ( canRun && !isCrouched && inForward && !FirstPersonWeaponSway.ironsightZoomed && !FirstPersonWeaponSway.ironsightZooming );
isRunning = ( InputSettings.GetAction( runBtnName, EActionEvent.Press ) && runReady );
/*
if( ASKInputManager.GetButtonDown( runBtnName ) && runReady )
HudElements.Crosshair.SetActive( ECrosshairView.None );
if( ASKInputManager.GetButtonUp( runBtnName ) )
WeaponsManager.UpdateHud( true );
if( !isRunning && ASKInputManager.GetButtonDown( runBtnName ) && runReady )
isRunning = true;
if( isRunning && !isMoving )
isRunning = false;
*/
float speed = isRunning ? runSpeed : walkSpeed;
speed = isCrouched ? speed * crouchSpeed : speed;
speed = ( isGrounded || ( isJumping && !jump ) ) ? speed : speed * inAirSpeed;
speed = isClimbing ? speed * climbingSpeed : speed;
return speed * FirstPersonWeaponSway.moveSpeed;
}
// Camera Look
private void CameraLook()
{
rotationX += ASKInputManager.lookHorizontal * Time.timeScale;
rotationY += ASKInputManager.lookVertical * Time.timeScale;
rotationY = Mathf.Clamp( rotationY, -maxLookAngleY, maxLookAngleY );
Quaternion camTargetRotation = nativeRotation * Quaternion.Euler( -1f * rotationY + ( useHeadBob ? CameraHeadBob.xTilt * tiltForce : 0f ), 0f, 0f );
Quaternion bodyTargetRotation = nativeRotation * Quaternion.Euler( 0f, rotationX + ( useHeadBob ? CameraHeadBob.yTilt * tiltForce : 0f ), 0f );
float smoothRotation = lookSmooth * ( Time.fixedDeltaTime * 50f );
cameraTransform.localRotation = Quaternion.Slerp( cameraTransform.localRotation, camTargetRotation, smoothRotation );
m_Transform.localRotation = Quaternion.Slerp( m_Transform.localRotation, bodyTargetRotation, smoothRotation );
Vector3 newCameraPosition = Vector3.zero;
newCameraPosition.x = m_Controller.center.x + cameraOffset.x + ( useHeadBob ? CameraHeadBob.xPos * posForce : 0f ); //xPos
newCameraPosition.y = ( m_Controller.center.y * 2f ) + cameraOffset.y + ( useHeadBob ? CameraHeadBob.yPos * posForce : 0f ); //yPos
newCameraPosition.z = m_Controller.center.z + cameraOffset.z;
cameraTransform.localPosition = newCameraPosition;
}
// StandUp
private m_IEnumerator StandUp()
{
Vector3 targetCenter = Vector3.up;
isCrouched = false;
while( PlayCrouchAnimation( ref targetCenter, ref nativeCapsuleHeight ) )
yield return null;
m_Controller.height = nativeCapsuleHeight;
m_Controller.center = targetCenter;
crouching = false;
}
// SitDown
private m_IEnumerator SitDown()
{
Vector3 targetCenter = Vector3.up * ( crouchHeight * .5f );
isCrouched = true;
while( PlayCrouchAnimation( ref targetCenter, ref crouchHeight ) )
yield return null;
m_Controller.height = crouchHeight;
m_Controller.center = targetCenter;
crouching = false;
}
// Play CrouchAnimation
private bool PlayCrouchAnimation( ref Vector3 targetCenter, ref float targetHeight )
{
m_Controller.height = Mathf.SmoothDamp( m_Controller.height, targetHeight, ref crouchVel, Time.fixedDeltaTime * 5f );
m_Controller.center = Vector3.SmoothDamp( m_Controller.center, targetCenter, ref crouchVelVec, Time.fixedDeltaTime * 5f );
const int digits = 3;
double cMag = System.Math.Round( ( double )m_Controller.center.magnitude, digits );
double tMag = System.Math.Round( ( double )targetCenter.magnitude, digits );
return ( cMag != tMag );
}
// Play FootStepAudio
private void PlayFootStepAudio()
{
if( !prevGrounded && isGrounded )
{
m_FootstepManager.PlayLandingSound( hitInfo );
nextStep = CameraHeadBob.headBobCycle + stepInterval;
isJumping = false;
moveDirection.y = 0f;
return;
}
if( CameraHeadBob.headBobCycle > nextStep )
{
nextStep = CameraHeadBob.headBobCycle + stepInterval;
if( isGrounded )
m_FootstepManager.PlayFootStepSound( hitInfo );
else if( isClimbing )
currentLadder.PlayLadderFootstepSound();
}
}
// Player Die
internal static void PlayerDie()
{
instance.enabled = false;
instance.m_Controller.height = .1f;
instance.m_Controller.radius = .1f;
//instance.GetComponent<CameraHeadBob>().enabled = false;
}
// OnController ColliderHit
void OnControllerColliderHit( ControllerColliderHit hit )
{
if( collisionFlags != CollisionFlags.Below )
{
Rigidbody tmpRb = hit.collider.attachedRigidbody;
if( tmpRb != null && !tmpRb.isKinematic )
tmpRb.AddForceAtPosition( hit.moveDirection, hit.point, ForceMode.Impulse );
}
}
// OnTrigger Enter
void OnTriggerEnter( Collider collider )
{
if( canClimb && !crouching && TagsManager.IsLadder( collider.tag ) )
{
if( isCrouched )
{
crouching = true;
StartCoroutine( StandUp() );
}
currentLadder = collider.GetComponent<ILadder>();
currentLadder.AssignAudioSource( this.GetComponent<AudioSource>() );
moveDirection = Vector3.zero;
isClimbing = true;
}
}
// OnTrigger Exit
void OnTriggerExit( Collider collider )
{
if( !crouching && TagsManager.IsLadder( collider.tag ) )
{
isClimbing = false;
currentLadder = null;
}
}
//
}
}
Comment