public Move ( |
||
move | ||
crouch | bool | |
jump | bool | |
return | void |
private void Update() { timeLeft -= Time.deltaTime; if (m_activated) { m_activated_delay -= Time.deltaTime; if (m_activated_delay < 0) { Vector3 predictionPos = transform.position; owner.GetComponent <UnityEngine.AI.NavMeshAgent>().Warp(predictionPos); owner.transform.position = predictionPos + Vector3.up * 0.1f; owner.GetComponent <UnityEngine.AI.NavMeshAgent>().ResetPath(); Destroy(gameObject); return; } } if (timeLeft < 0 && !m_activated) { DestroySpell(); return; } if (target != null) { agent.SetDestination(target.position); } if (agent.remainingDistance > agent.stoppingDistance) { thirdPersonController.Move(agent.desiredVelocity, false, false); } else { thirdPersonController.Move(Vector3.zero, false, false); } }
void patrol() { Vector3 target = waypoint[currentWaypoint].position; target.y = transform.position.y; // $$anonymous$$eep waypoint at character's height Vector3 moveDirection = target - transform.position; if (moveDirection.magnitude < 0.5f) { if (curTime == 0) { curTime = Time.time; // Pause over the Waypoint } if ((Time.time - curTime) >= pauseDuration) { currentWaypoint++; curTime = 0; } } else { var rotation = Quaternion.LookRotation(target - transform.position); transform.rotation = Quaternion.Slerp(transform.rotation, rotation, Time.deltaTime * dampingLook); character.Move(moveDirection.normalized * patrolSpeed, false, false); } }
private void Move() { if (target != null) { agent.SetDestination(target.position); } if (agent.remainingDistance > agent.stoppingDistance) { character.Move(agent.desiredVelocity, false, false); } else { character.Move(Vector3.zero, false, false); } }
private void Update() { if (target != null) { agent.SetDestination(target.position); } if (agent.remainingDistance > agent.stoppingDistance) { thirdPersonController.Move(agent.desiredVelocity, false, false); } else { thirdPersonController.Move(Vector3.zero, false, false); } }
// Update is called once per frame void Update() { // Movement if there is a target to move to if (target != null) { agent.SetDestination(target.position); } if (agent.remainingDistance > agent.stoppingDistance) { character.Move(agent.desiredVelocity, false, false); } else { character.Move(Vector3.zero, false, false); } }
// Fixed update is called in sync with physics private void FixedUpdate() { // read inputs float h, v; if (Application.isEditor) { h = Input.GetAxis("Horizontal"); v = Input.GetAxis("Vertical"); } else { h = -Input.acceleration.x; v = -Input.acceleration.z; } bool crouch = Input.GetKey(KeyCode.C); // calculate move direction to pass to character if (m_Cam != null) { // calculate camera relative direction to move: m_CamForward = Vector3.Scale(m_Cam.forward, new Vector3(1, 0, 1)).normalized; m_Move = v * m_CamForward + h * m_Cam.right; } else { // we use world-relative directions in the case of no main camera m_Move = v * Vector3.forward + h * Vector3.right; } // walk speed multiplier if (Input.GetKey(KeyCode.LeftShift) && Application.isEditor) { m_Move *= 0.5f; } if (v > 0.01f) { audioSource.UnPause(); } else { audioSource.Pause(); } // pass all parameters to the character control script m_Character.Move(m_Move * 3f, crouch, m_Jump); m_Character.transform.Rotate(Input.acceleration.x * m_Cam.up * 3f); m_Jump = false; }
// Fixed update is called in sync with physics private void FixedUpdate() { bool crouch = Input.GetKey(KeyCode.C); // calculate move direction to pass to character if (m_Cam != null) { // calculate camera relative direction to move: m_CamForward = Vector3.Scale(m_Cam.forward, new Vector3(1, 0, 1)).normalized; m_Move = _veritcal * m_CamForward + _horizontal * m_Cam.right; } else { // we use world-relative directions in the case of no main camera m_Move = _veritcal * Vector3.forward + _horizontal * Vector3.right; } #if !MOBILE_INPUT // walk speed multiplier if (Input.GetKey(KeyCode.LeftShift)) { m_Move *= 0.5f; } #endif // pass all parameters to the character control script if (player_made_move) // This ensures movement vector isn't passed to character controller unless the player intends to be moving // (otherwise, when at a stand-still but moving the camera, player character will still turn to reorient himself relative // to the camera forward position, which is how it works in for example Jedi Outcast, Indiana Jones Emperor's Tomb IIRC // but is not used in newer games like Sleeping Dogs or even Zelda Wind Waker iirc { m_Character.Move(m_Move, crouch, m_Jump); } else { m_Character.Move(Vector3.zero, crouch, m_Jump); } m_Jump = false; }
// Fixed update is called in sync with physics private void FixedUpdate() { if (!isCaught) { // read inputs float h = CrossPlatformInputManager.GetAxis("Horizontal"); float v = CrossPlatformInputManager.GetAxis("Vertical"); bool crouch = Input.GetKey(KeyCode.LeftControl); // calculate move direction to pass to character if (m_Cam != null) { // calculate camera relative direction to move: m_CamForward = Vector3.Scale(m_Cam.forward, new Vector3(1, 0, 1)).normalized; m_Move = v * m_CamForward + h * m_Cam.right; } else { // we use world-relative directions in the case of no main camera m_Move = v * Vector3.forward + h * Vector3.right; } #if !MOBILE_INPUT // walk speed multiplier if (Input.GetKey(KeyCode.LeftShift)) { m_Move *= 0.5f; } #endif // pass all parameters to the character control script m_Character.Move(m_Move, crouch, m_Jump); m_Jump = false; } else { m_Character.Move(new Vector3(0, 0, 0), true, false); } }
// Fixed update is called in sync with physics private void FixedUpdate() { // read inputs float h = 0; if (Input.GetKey(KeyCode.A)) { h = -1; } if (Input.GetKey(KeyCode.D)) { h = 1; } float v = 0; if (Input.GetKey(KeyCode.S)) { v = -1; } if (Input.GetKey(KeyCode.W)) { v = 1; } bool crouch = Input.GetKey(KeyCode.C); // calculate move direction to pass to character if (m_Cam != null) { // calculate camera relative direction to move: m_CamForward = Vector3.Scale(m_Cam.forward, new Vector3(1, 0, 1)).normalized; m_Move = v * m_CamForward + h * m_Cam.right; } else { // we use world-relative directions in the case of no main camera m_Move = v * Vector3.forward + h * Vector3.right; } #if !MOBILE_INPUT // walk speed multiplier if (Input.GetKey(KeyCode.LeftShift)) { m_Move *= 0.5f; } #endif // pass all parameters to the character control script m_Character.Move(m_Move, crouch, m_Jump); m_Jump = false; }
// Fixed update is called in sync with physics private void FixedUpdate() { // read inputs bool crouch = Input.GetKey(KeyCode.C); float v = Mathf.Abs(CrossPlatformInputManager.GetAxis("Vertical")); m_Move = v * Vector3.forward; // pass all parameters to the character control script m_Character.Move(m_Move, crouch, m_Jump); m_Jump = false; }
private void Update() { character.GetComponentInChildren <Camera> ().transform.LookAt(player); if (IsObjectCloserThan(player, 5f)) { Debug.Log(character.tag + " is running away!"); MoveFromPlayer(); } else { Debug.Log(character.tag + " is hiding!"); Transform wall = FindClosestWall(); if (!IsObjectCloserThan(wall, 3f)) { MoveToObject(wall); } else { character.Move(Vector3.zero, false, false); } } }
// Fixed update is called in sync with physics private void FixedUpdate() { // read inputs bool crouch = Input.GetKey(KeyCode.C); #if !MOBILE_INPUT // walk speed multiplier #endif // pass all parameters to the character control script m_Character.Move(m_Move, crouch, m_Jump); m_Jump = false; }
// Fixed update is called in sync with physics private void FixedUpdate() { // read inputs float h = CrossPlatformInputManager.GetAxis("Horizontal"); float v = CrossPlatformInputManager.GetAxis("Vertical"); bool crouch = Input.GetKey(KeyCode.C); // we use world-relative directions in the case of no main camera m_Move = v * Vector3.forward + h * Vector3.right; // pass all parameters to the character control script m_Character.Move(m_Move, crouch, m_Jump); m_Jump = false; }
// Fixed update is called in sync with physics private void FixedUpdate() { #if !MOBILE_INPUT // walk speed multiplier if (Input.GetKey(KeyCode.LeftShift)) { m_Move *= 0.5f; } #endif // pass all parameters to the character control script m_Character.Move(m_Move, false, m_Jump); m_Jump = false; }
void Patrol() { agent.speed = patrolSpeed; if (Vector3.Distance(this.transform.position, waypoints[waypointInd].transform.position) >= 2) { agent.SetDestination(waypoints[waypointInd].transform.position); character.Move(agent.desiredVelocity, false, false); } else if (Vector3.Distance(this.transform.position, waypoints[waypointInd].transform.position) <= 2) { waypointInd++; if (waypointInd >= waypoints.Length) { waypointInd = 0; } } else { character.Move(Vector3.zero, false, false); } }
// private void LateUpdate(){ // oldPosition = transform.position; // } // Fixed update is called in sync with physics private void FixedUpdate() { if (amIServer == networkObject.IsServer) { Camera.main.GetComponent <TPMCameraMove>().setServer(amIServer); // read inputs float h = CrossPlatformInputManager.GetAxis("Horizontal"); float v = CrossPlatformInputManager.GetAxis("Vertical"); bool crouch = Input.GetKey(KeyCode.C); // calculate move direction to pass to character if (m_Cam != null) { // calculate camera relative direction to move: m_CamForward = Vector3.Scale(m_Cam.forward, new Vector3(1, 0, 1)).normalized; m_Move = v * m_CamForward + h * m_Cam.right; } else { // we use world-relative directions in the case of no main camera m_Move = v * Vector3.forward + h * Vector3.right; } #if !MOBILE_INPUT // walk speed multiplier if (Input.GetKey(KeyCode.LeftShift)) { m_Move *= 2.0f; } #endif m_Character.Move(m_Move, crouch, m_Jump); // networkObject.SendRpc(RPC_MOVE, Receivers.AllBuffered, transform.position, transform.rotation); networkObject.SendRpc(RPC_MOVE, Receivers.AllBuffered, m_Move, crouch, m_Jump); m_Jump = false; } }
// Fixed update is called in sync with physics private void FixedUpdate() { // read inputs float h = CrossPlatformInputManager.GetAxis("Horizontal"); float v = CrossPlatformInputManager.GetAxis("Vertical"); print("h: " + h + ", v: " + v); if (Application.loadedLevelName != "Base") { crouch = CrossPlatformInputManager.GetButton("Crouch"); } // calculate move direction to pass to character if (m_Cam != null) { // calculate camera relative direction to move: m_CamForward = Vector3.Scale(m_Cam.forward, new Vector3(1, 0, 1)).normalized; m_Move = v * m_CamForward + h * m_Cam.right; } else { // we use world-relative directions in the case of no main camera m_Move = v * Vector3.forward + h * Vector3.right; } #if !MOBILE_INPUT // walk speed multiplier var attack = GetComponent <ThirdPersonLogic>(); if (attack.isAttacking == true) { m_Move *= 0f; } else { m_Move *= 1f; } if (Input.GetKey(KeyCode.LeftShift)) { m_Move *= 0.5f; } if (Input.GetKey(KeyCode.R)) { m_Move *= 100.0f; } #endif // pass all parameters to the character control script m_Character.Move(m_Move, crouch, m_Jump); m_Jump = false; }
// Fixed update is called in sync with physics private void FixedUpdate() { //added code float h = 0f; float v = 0f; // read inputs according to character's name if (this.name == "Guardian") { h = CrossPlatformInputManager.GetAxis("Horizontal1"); v = CrossPlatformInputManager.GetAxis("Vertical1"); } else if (this.name == "thief1") { h = CrossPlatformInputManager.GetAxis("Horizontal2"); v = CrossPlatformInputManager.GetAxis("Vertical2"); } else { h = CrossPlatformInputManager.GetAxis("Horizontal3"); v = CrossPlatformInputManager.GetAxis("Vertical3"); } //added code ends here bool crouch = Input.GetKey(KeyCode.C); // calculate move direction to pass to character if (m_Cam != null) { // calculate camera relative direction to move: m_CamForward = Vector3.Scale(m_Cam.forward, new Vector3(1, 0, 1)).normalized; m_Move = v * m_CamForward + h * m_Cam.right; } else { // we use world-relative directions in the case of no main camera m_Move = v * Vector3.forward + h * Vector3.right; } #if !MOBILE_INPUT // walk speed multiplier if (Input.GetKey(KeyCode.LeftShift)) { m_Move *= 0.5f; } #endif // pass all parameters to the character control script m_Character.Move(m_Move, crouch, m_Jump); m_Jump = false; }
// Fixed update is called in sync with physics private void FixedUpdate() { // read inputs float h = CrossPlatformInputManager.GetAxis("Horizontal"); float v = CrossPlatformInputManager.GetAxis("Vertical"); m_Input = new Vector2(h, v); bool crouch = Input.GetKey(KeyCode.C); Vector2 facingDirection = new Vector2(h, v); Vector3 desiredMove = transform.forward * m_Input.y + transform.right * m_Input.x; // get a normal for the surface that is being touched to move along it RaycastHit hitInfo; Physics.SphereCast(transform.position, controller_radius, Vector3.down, out hitInfo, controller_height / 2f, Physics.AllLayers, QueryTriggerInteraction.Ignore); desiredMove = Vector3.ProjectOnPlane(desiredMove, hitInfo.normal).normalized; float speed = 1.0f; #if !MOBILE_INPUT // walk speed multiplier if (Input.GetKey(KeyCode.LeftShift)) { speed = 1.5f; } #endif m_MoveDir.x = desiredMove.x * speed; m_MoveDir.z = desiredMove.z * speed; /* * // calculate move direction to pass to character * if (m_Cam != null) * { * // calculate camera relative direction to move: * m_CamForward = Vector3.Scale(m_Cam.forward, new Vector3(1, 0, 1)).normalized; * m_Move = v*m_CamForward + h*m_Cam.right; * } * else * { * // we use world-relative directions in the case of no main camera * m_Move = v*Vector3.forward + h*Vector3.right; * } */ // pass all parameters to the character control script m_Character.Move(m_MoveDir, crouch, m_Jump); m_Jump = false; }
// Fixed update is called in sync with physics private void FixedUpdate() { // read inputs float h = CrossPlatformInputManager.GetAxis("Horizontal"); float v = CrossPlatformInputManager.GetAxis("Vertical"); bool crouch = Input.GetKey(KeyCode.C); // calculate move direction to pass to character if (m_Cam != null) { // calculate camera relative direction to move: //Debug.Log("hello"); //m_CamForward = Vector3.Scale (m_Cam.forward, new Vector3 (1, 0, 1)).normalized; //m_Move = v*m_CamForward + h*m_Cam.right; //mata change the moving direction calculation. Vector3 _camForward = Vector3.Normalize(transform.position - m_Cam.position); _camForward = m_Cam.forward; Vector3 _camRight = Vector3.Normalize(Vector3.Cross(_camForward, Vector3.up)); _camRight = m_Cam.right; if (transform.up.y < -0.8f) { m_Move = v * Vector3.Normalize(Vector3.Cross(_camRight, _camForward)) + h * _camRight; }//player on the ceil else if (transform.up.y > 0.8f) { m_Move = v * _camForward + h * _camRight; }//player on the floor else { m_Move = v * Vector3.up + h * _camRight; }//player on the wall //m_Move = v * this.gameObject.transform.forward + h * this.gameObject.transform.right; } else { // we use world-relative directions in the case of no main camera //m_Move = v * Vector3.forward + h * Vector3.right; } #if !MOBILE_INPUT // walk speed multiplier //if (Input.GetKey (KeyCode.LeftShift)) m_Move *= 0.5f; //mata :no walking mode #endif // pass all parameters to the character control script m_Character.Move(m_Move, crouch, m_Jump); m_Jump = false; }
void Wonder() { agent.speed = patrolSpeed; //Uzstāda ātrumu kādā pārvietosies AI if (Vector3.Distance(this.transform.position, waypoints[random].transform.position) >= 1f) //novērtē vai distance starp AI un waypoiuntu ir >= 1 { agent.SetDestination(waypoints[random].transform.position); //Uzstāda aģentam mērķi character.Move(agent.desiredVelocity, false, false); // Notiek AI kustēšanās uz mērķi } else { //Ja ir sasniedzis mērķi character.Move(Vector3.zero, false, false); //Aptur AI kustību int num = UnityEngine.Random.Range(1, 3); //nosaka num vērtību izmantojot random(50% iespēja) if (num == 1) { state = basicAI.State.TROLLING; // maina state uz trolling } else { state = basicAI.State.LOOKING; // maina state uz looking } } }
// Fixed update is called in sync with physics private void FixedUpdate() { // read inputs // Create a parent gameObject that is the Agent. // Move these into the Agent's Heuristic(). // Create a public variable for forward and sideways in this script // Reference it in the Agent script: userControl = GetComponentInChildren<ThirdPersonUserControl>(); // And set the vaule of it in OnActionReceived() { // userControl.verticalInput = vectorAction[0]; // userControl.horizontalInput = vectorAction[1]; } // // float h = horizontalInput; float v = verticalInput; bool crouch = Input.GetKey(KeyCode.C); // calculate move direction to pass to character if (m_Cam != null) { // calculate camera relative direction to move: m_CamForward = Vector3.Scale(m_Cam.forward, new Vector3(1, 0, 1)).normalized; m_Move = v * m_CamForward + h * m_Cam.right; } else { // we use world-relative directions in the case of no main camera m_Move = v * Vector3.forward + h * Vector3.right; } #if !MOBILE_INPUT // walk speed multiplier if (Input.GetKey(KeyCode.LeftShift)) { m_Move *= 0.5f; } #endif // pass all parameters to the character control script m_Character.Move(m_Move, crouch, m_Jump); m_Jump = false; if (transform.position.y < -5) { playerAgent.EndEpisode(); } }
// Fixed update is called in sync with physics private void FixedUpdate() { // read inputs float h = CrossPlatformInputManager.GetAxis("Horizontal"); float v = CrossPlatformInputManager.GetAxis("Vertical"); bool crouch = Input.GetKey(KeyCode.C); yaw += Input.GetAxis("Mouse X") * mouseSensitivity; pitch -= Input.GetAxis("Mouse Y") * mouseSensitivity * 0; currentRotation = Vector3.SmoothDamp(currentRotation, new Vector3(pitch, yaw), ref rotationSmoothVelocity, rotationSmoothTime); transform.eulerAngles = currentRotation; /* yaw += Input.GetAxis("Mouse X") * mouseSensitivity; * pitch -= Input.GetAxis("Mouse Y") * mouseSensitivity * 0; * * currentRotation = Vector3.SmoothDamp(currentRotation, new Vector3(pitch, yaw), ref rotationSmoothVelocity, rotationSmoothTime); * transform.eulerAngles = currentRotation; */ // calculate move direction to pass to character if (m_Cam != null) { // calculate camera relative direction to move: // m_Move = v * Vector3.forward + h * Vector3.right; m_CamForward = Vector3.Scale(m_Cam.forward, new Vector3(1, 0, 1)).normalized; m_Move = v * m_CamForward + h * m_Cam.right; } else { // we use world-relative directions in the case of no main camera m_Move = v * Vector3.forward + h * Vector3.right; } #if !MOBILE_INPUT // walk speed multiplier if (Input.GetKey(KeyCode.LeftShift)) { m_Move *= 0.5f; } #endif // pass all parameters to the character control script m_Character.Move(m_Move, crouch, m_Jump, yaw); m_Jump = false; }
// Fixed update is called in sync with physics private void FixedUpdate() { // read inputs float h; float v; if (useMobileInput) { h = Hinput; v = Vinput; } else { h = Input.GetAxis("Horizontal"); v = Input.GetAxis("Vertical"); crouch = Input.GetKey(KeyCode.C); } // calculate move direction to pass to character if (m_Cam != null) { // calculate camera relative direction to move: m_CamForward = Vector3.Scale(m_Cam.forward, new Vector3(1, 0, 1)).normalized; m_Move = v * m_CamForward + h * m_Cam.right; } else { // we use world-relative directions in the case of no main camera m_Move = v * Vector3.forward + h * Vector3.right; } #if !MOBILE_INPUT // walk speed multiplier if (Input.GetKey(KeyCode.LeftShift)) { m_Move *= 0.5f; } #endif // pass all parameters to the character control script m_Character.Move(m_Move, crouch, m_Jump); m_Jump = false; }
// Fixed update is called in sync with physics private void FixedUpdate() { int A0 = Interact_Arduino.analogValues.a; //up buttom int A1 = Interact_Arduino.analogValues.b; //right buttom int A2 = Interact_Arduino.analogValues.c; //left buttom // read inputs float h = 0; if (A1 > 512) { h = A1; } else if (A2 > 512) { h -= A2; } //float v = CrossPlatformInputManager.GetAxis("Vertical"); float v = A0; bool crouch = Input.GetKey(KeyCode.C); // calculate move direction to pass to character if (m_Cam != null) { // calculate camera relative direction to move: m_CamForward = Vector3.Scale(m_Cam.forward, new Vector3(1, 0, 1)).normalized; m_Move = v * m_CamForward + h * m_Cam.right; } else { // we use world-relative directions in the case of no main camera m_Move = v * Vector3.forward + h * Vector3.right; } #if !MOBILE_INPUT // walk speed multiplier if (Input.GetKey(KeyCode.LeftShift)) { m_Move *= 0.5f; } #endif // pass all parameters to the character control script m_Character.Move(m_Move, crouch, m_Jump); m_Jump = false; }
// Fixed update is called in sync with physics private void FixedUpdate() { // Debug.Log("H:" + Input.GetAxis("Mouse X")); // Debug.Log("cpi:" + CrossPlatformInputManager.GetAxis("Mouse X")); // read inputs float h = CrossPlatformInputManager.GetAxis("Horizontal"); float v = CrossPlatformInputManager.GetAxis("Vertical"); // Debug.Log("h:" + h + " v:" + v); bool fire = CrossPlatformInputManager.GetButtonDown("Fire1"); if (fire) { _animator.SetTrigger("Shoot"); } bool crouch = Input.GetKey(KeyCode.C); // calculate move direction to pass to character //however the camera is rotating is where we need to move to if (m_Cam != null) { // calculate camera relative direction to move: //We will only move the camera in the x and z based on user input m_CamForward = Vector3.Scale(m_Cam.forward, new Vector3(1, 0, 1)).normalized; // Debug.Log("CamForward:" + m_CamForward); m_Move = v * m_CamForward + h * m_Cam.right; // Debug.Log("Move is:" + m_Move); } else { // we use world-relative directions in the case of no main camera m_Move = v * Vector3.forward + h * Vector3.right; } #if !MOBILE_INPUT // walk speed multiplier if (Input.GetKey(KeyCode.LeftShift)) { m_Move *= 0.5f; } #endif // pass all parameters to the character control script m_Character.Move(m_Move, crouch, m_Jump); m_Jump = false; }
// Fixed update is called in sync with physics private void FixedUpdate() { // read inputs float h = CrossPlatformInputManager.GetAxis("Horizontal"); float v = CrossPlatformInputManager.GetAxis("Vertical"); bool crouch = Input.GetKey(KeyCode.C); // calculate camera relative direction to move: m_CamForward = Vector3.Scale(m_Cam.forward, new Vector3(1, 0, 1)).normalized; m_Move = v * m_CamForward + h * m_Cam.right; // pass all parameters to the character control script m_Character.Move(m_Move, crouch, m_Jump); m_Jump = false; }
// Fixed update is called in sync with physics private void FixedUpdate() { // read inputs float h = CrossPlatformInputManager.GetAxis("Mouse X"); float v = CrossPlatformInputManager.GetAxis("Vertical"); if (v < 0) { v = 0; } bool crouch = Input.GetKey(KeyCode.LeftControl); m_Move = v * gameObject.transform.forward + h * gameObject.transform.right; // pass all parameters to the character control script m_Character.Move(m_Move, crouch, m_Jump); m_Jump = false; }
// Fixed update is called in sync with physics private void FixedUpdate() { if (enventoryOn) { h = h - .3f; if (v < 0) { v = v + .3f; if (v > 0) { v = 0; } } else { if (v > 0) { v = v - .3f; if (v < 0) { v = 0; } } } if (h < 0) { h = 0; } } else { h = CrossPlatformInputManager.GetAxis("Horizontal"); v = CrossPlatformInputManager.GetAxis("Vertical"); } v = v + Math.Abs(h / 2); if (v > 1f) { v = 1f; } m_Move = new Vector3(h / 2, 0, v); m_Character.Move(m_Move, m_Jump); }
// Fixed update is called in sync with physics private void FixedUpdate() { // read inputs float h = CrossPlatformInputManager.GetAxis("Horizontal"); float v = CrossPlatformInputManager.GetAxis("Vertical"); bool crouch = Input.GetKey(KeyCode.C); // calculate move direction to pass to character if (m_Cam != null) { // calculate camera relative direction to move: m_CamForward = Vector3.Scale(m_Cam.forward, new Vector3(1, 0, 1)).normalized; m_Move = v * m_CamForward + h * m_Cam.right; } else { // we use world-relative directions in the case of no main camera m_Move = v * Vector3.forward + h * Vector3.right; } #if !MOBILE_INPUT // walk speed multiplier if (Input.GetKey(KeyCode.LeftShift)) { m_Move *= 0.5f; } #endif if (!Input.GetKey(KeyCode.LeftShift)) { // pass all parameters to the character control script rgb.useGravity = true; m_Character.Move(m_Move, crouch, m_Jump); m_Jump = false; } else { rgb.useGravity = false; rgb.velocity = new Vector3(0, 0, 0); if (Input.GetKey(KeyCode.W)) { transform.position = transform.position + Camera.main.transform.forward * cheatSpeed * Time.deltaTime; } } }