We Keep Coding

Input.GetKeyDown calls a coroutine to put in 1st person but it blocks my character's movements

In this script, I call a coroutine using Input; this coroutine allows that if we press F5, change the view of our character that we see in 3rd person mode to 1st person mode and if we press F5 again, it will replace the view. Only, by using input.GetKey and not input.GetKeyDown the coroutine will read several times which gives an ugly result. But when I use Input.GetKeyDown, and I'm in 1st person mode (the basic view is in 3rd person) my character's movements are blocked: I can't move forward, backward, jump etc... error in the script ?
If you want to test on unity, just download the file on this link https://github.com/TUTOUNITYFR/unitypackages-jeu-survie-2022-tufr/blob/main/Episode01/personnage-et-environnement.unitypackage then in the AimBehaviourBasic script, replace all the code with:
`
using UnityEngine;
using System.Collections;
// AimBehaviour inherits from GenericBehaviour. This class corresponds to aim and strafe behaviour.
public class AimBehaviourBasic : GenericBehaviour
{
public Texture2D crosshair; // Crosshair texture.
public float aimTurnSmoothing = 0.15f; // Speed of turn response when aiming to match camera facing.
public Vector3 aimPivotOffset = new Vector3(0.5f, 1.2f, 0f); // Offset to repoint the camera when aiming.
public Vector3 aimCamOffset = new Vector3(0f, 0.4f, -0.7f); // Offset to relocate the camera when aiming.
private int aimBool; // Animator variable related to aiming.
public bool aim; // Boolean to determine whether or not the player is aiming.
// Start is always called after any Awake functions.
void Start ()
{
// Set up the references.
aimBool = Animator.StringToHash("Aim");
}
// Update is used to set features regardless the active behaviour.
void Update ()
{
// Activate/deactivate aim by input.
if (Input.GetKeyDown (KeyCode.F5) && !aim)
{
StartCoroutine(ToggleAimOn());
}
else
if (Input.GetKeyDown (KeyCode.F5) && aim)
{
StartCoroutine(ToggleAimOff());
}
}
// Co-rountine to start aiming mode with delay.
private IEnumerator ToggleAimOn()
{
yield return new WaitForSeconds(0.05f);
// Aiming is not possible.
if (behaviourManager.GetTempLockStatus(this.behaviourCode) || behaviourManager.IsOverriding(this))
yield return false;
// Start aiming.
else
{
aim = true;
int signal = 1;
yield return new WaitForSeconds(0.1f);
aimCamOffset.x = Mathf.Abs(aimCamOffset.x) * signal;
aimPivotOffset.x = Mathf.Abs(aimPivotOffset.x) * signal;
yield return new WaitForSeconds(0.1f);
behaviourManager.GetAnim.SetFloat(speedFloat, 0);
// This state overrides the active one.
behaviourManager.OverrideWithBehaviour(this);
}
}
// Co-rountine to end aiming mode with delay.
private IEnumerator ToggleAimOff()
{
aim = false;
yield return new WaitForSeconds(0.3f);
behaviourManager.GetCamScript.ResetTargetOffsets();
behaviourManager.GetCamScript.ResetMaxVerticalAngle();
yield return new WaitForSeconds(0.05f);
behaviourManager.RevokeOverridingBehaviour(this);
}
// LocalFixedUpdate overrides the virtual function of the base class.
public override void LocalFixedUpdate()
{
// Set camera position and orientation to the aim mode parameters.
if(aim)
{
behaviourManager.GetCamScript.SetTargetOffsets (aimPivotOffset, aimCamOffset);
}
}
// LocalLateUpdate: manager is called here to set player rotation after camera rotates, avoiding flickering.
public override void LocalLateUpdate()
{
AimManagement();
}
// Handle aim parameters when aiming is active.
void AimManagement()
{
// Deal with the player orientation when aiming.
Rotating();
}
// Rotate the player to match correct orientation, according to camera.
void Rotating()
{
// Always rotates the player according to the camera horizontal rotation in aim mode.
Quaternion targetRotation = Quaternion.Euler(0, behaviourManager.GetCamScript.GetH, 0);
float minSpeed = Quaternion.Angle(transform.rotation, targetRotation) * aimTurnSmoothing;
// Rotate entire player to face camera.
transform.rotation = Quaternion.Slerp(transform.rotation, targetRotation, minSpeed * Time.deltaTime);
}
// Draw the crosshair when aiming.
void OnGUI ()
{
if (crosshair)
{
float mag = behaviourManager.GetCamScript.GetCurrentPivotMagnitude(aimPivotOffset);
GUI.DrawTexture(new Rect(Screen.width / 2 - (crosshair.width * 0.5f),
Screen.height / 2 - (crosshair.height * 0.5f),
crosshair.width, crosshair.height), crosshair);
}
}
}
`
Now you can test, press play and then press F5: the camera will change position but if you try to move (les touches : Z,Q,S,D, escape or arrowUp, arrowDown etc..) absolutely nothing will happen: here is my problem... Sorry for my bad English I am French ; )

Using coroutines like this will mess up your code because both coroutines can run almost at the same time, for example:
If you press F5 the first time ToggleAimOn() will be executed but before it get's finished you can press F5 again and call ToggleAimOff(), and since coroutines are async, that means they can run at the same time so it will create a real messed up behaviour
What you can try is to have another flag beside aim that will check if a coroutine is running like this:
private bool IsCoroutineActive = false;
void Update ()
{
// Activate/deactivate aim by input.
if (Input.GetKeyDown (KeyCode.F5) && !IsCoroutineActive && !aim)
{
StartCoroutine(ToggleAimOn());
}
else
if (Input.GetKeyDown (KeyCode.F5) && !IsCoroutineActive && aim)
{
StartCoroutine(ToggleAimOff());
}
}
// Co-rountine to start aiming mode with delay.
private IEnumerator ToggleAimOn()
{
IsCoroutineActive = true;
yield return new WaitForSeconds(0.05f);
// Aiming is not possible.
if (behaviourManager.GetTempLockStatus(this.behaviourCode) || behaviourManager.IsOverriding(this))
{
IsCoroutineActive = false;
yield return false;
}
// Start aiming.
else
{
aim = true;
int signal = 1;
yield return new WaitForSeconds(0.1f);
aimCamOffset.x = Mathf.Abs(aimCamOffset.x) * signal;
aimPivotOffset.x = Mathf.Abs(aimPivotOffset.x) * signal;
yield return new WaitForSeconds(0.1f);
behaviourManager.GetAnim.SetFloat(speedFloat, 0);
// This state overrides the active one.
behaviourManager.OverrideWithBehaviour(this);
}
IsCoroutineActive = false;
}
// Co-rountine to end aiming mode with delay.
private IEnumerator ToggleAimOff()
{
IsCoroutineActive = true;
aim = false;
yield return new WaitForSeconds(0.3f);
behaviourManager.GetCamScript.ResetTargetOffsets();
behaviourManager.GetCamScript.ResetMaxVerticalAngle();
yield return new WaitForSeconds(0.05f);
behaviourManager.RevokeOverridingBehaviour(this);
IsCoroutineActive = false;
}

Setting a fire rate for a weapon in Unity

I am trying to set a fire rate in Unity so that when I hold down up arrow, I will shoot a projectile up every 1 second. Currently my code is shooting a projectile every frame update, even though I have a Coroutine set up.
public GameObject bulletPrefab;
public float bulletSpeed;
public float fireRate = 1f;
public bool allowFire = true;
void Update()
{
//shooting input
if (Input.GetKey(KeyCode.UpArrow) && allowFire == true)
{
StartCoroutine(Shoot("up"));
}
}
IEnumerator Shoot(string direction)
{
allowFire = false;
if (direction == "up")
{
var bulletInstance = Instantiate(bulletPrefab, new Vector3(transform.position.x, transform.position.y, transform.position.z + 1), Quaternion.identity);
bulletInstance.GetComponent<Rigidbody>().AddForce(Vector3.forward * bulletSpeed);
}
yield return new WaitForSeconds(fireRate);
allowFire = true;
}

Coroutine
You can use the coroutine, but since you're calling it in an Update loop you much wait for it to finish before starting another one.
Coroutine currentCoroutine;
if(currentCoroutine == null)
currentCoroutine = StartCoroutine(DoShoot());
IEnumerator DoShoot() {
// Shoot.
yield return new WaitForSeconds(1f);
currentCoroutine = null;
}
Timestamp
You can also use a timestamp for when cooldown is ready. It's basically current time plus some duration.
float cooldown = 1f;
float cooldownTimestamp;
bool TryShoot (Vector2 direction) {
if (Time.time < cooldownTimestamp) return false;
cooldownTimestamp = Time.time + cooldown;
// Shoot!
}

I usually end up doing something like:
Variables
[Serializefield] float shootDelay = 1f;
float T_ShootDelay
Start()
T_ShootDelay = shootDelay;
Update()
if(T_ShootDelay < shootDelay)
T_ShootDelay += Time.deltaTime;
ShootInput()
if(T_ShootDelay >= shootDelay)
{
T_ShootDelay = 0;
Shoot();
}
What this does is:
Check if the shootDelay timer is less than the shootDelay.
Add up the timer by 1 per second.
Check the timer's status every time you want to shoot.
Set the timer to 0 after shooting

Considering a M4 AR that fires at least 700 rounds per minute.
700 rounds / 60 (seconds) ~= 11,66 rounds per second
1 second / 11 rounds ~= 0,085 seconds of delay between each round
You could simply try this:
yield return new WaitForSeconds(1 / (fireRate / 60f));

Unity 3D How to check if a gameobject remained in the same position every x amount of time?

this is the code I managed to come up with, the output isn't consistent. I assume it has something to do with the code not being looped properly. Can somebody tell me what I am doing wrong please?
The issue seems to be after X seconds have passed, it will continually check positions without waiting for the time to pass.
IEnumerator checkPosition()
{
while (true)
{
yield return new WaitForSeconds(X);
newpos = this.gameObject.transform.position;
//Debug.Log(newpos);
if (oldpos == newpos)
{
Debug.Log("Player remained idle");
}else if (oldpos != newpos)
{
Debug.Log("Player moved");
}
oldpos = newpos;
}
}
void Start()
{
oldpos = this.gameObject.transform.position;
}
void Update()
{
StartCoroutine(checkPosition());
}

Your code checks object's position only once after X amount of time. You need to loop your check routine.
IEnumerator checkPosition()
{
while (true)
{
yield return new WaitForSeconds(X);
newpos = this.gameObject.transform.position;
//Debug.Log(newpos);
if (oldpos == newpos)
{
Debug.Log("Player remained idle");
}else if (oldpos != newpos)
{
Debug.Log("Player moved");
}
oldpos = newpos;
}
}
UPDATE:
You need to start your coroutine in Start. The Update method is executed every frame. So you start the coroutine without waiting for the X amount of time. When you start your coroutine in Start, it will be executed only once and will run pseudo-parallel.

Have a thread wait without using Thread.sleep c# [duplicate]

How can I put a sleep function between the TextUI.text = ...., to wait 3 seconds between each phrase?
public Text GuessUI;
public Text TextUI;
[...truncated...]
TextUI.text = "Welcome to Number Wizard!";
TextUI.text = ("The highest number you can pick is " + max);
TextUI.text = ("The lowest number you can pick is " + min);
I already tried various things but none have worked, such as this:
TextUI.text = "Welcome to Number Wizard!";
yield WaitForSeconds (3);
TextUI.text = ("The highest number you can pick is " + max);
yield WaitForSeconds (3);
TextUI.text = ("The lowest number you can pick is " + min);
In bash, it would be:
echo "Welcome to Number Wizard!"
sleep 3
echo "The highest number you can pick is 1000"
sleep 3
.....
but I can't figure out how to do this in Unity with C#

There are many ways to wait in Unity. They are really simple but I think it's worth covering most ways to do it:
1.With a coroutine and WaitForSeconds.
This is by far the simplest way. Put all the code that you need to wait for some time in a coroutine function then you can wait with WaitForSeconds. Note that in coroutine function, you call the function with StartCoroutine(yourFunction).
Example below will rotate 90 deg, wait for 4 seconds, rotate 40 deg and wait for 2 seconds, and then finally rotate rotate 20 deg.
void Start()
{
StartCoroutine(waiter());
}
IEnumerator waiter()
{
//Rotate 90 deg
transform.Rotate(new Vector3(90, 0, 0), Space.World);
//Wait for 4 seconds
yield return new WaitForSeconds(4);
//Rotate 40 deg
transform.Rotate(new Vector3(40, 0, 0), Space.World);
//Wait for 2 seconds
yield return new WaitForSeconds(2);
//Rotate 20 deg
transform.Rotate(new Vector3(20, 0, 0), Space.World);
}
2.With a coroutine and WaitForSecondsRealtime.
The only difference between WaitForSeconds and WaitForSecondsRealtime is that WaitForSecondsRealtime is using unscaled time to wait which means that when pausing a game with Time.timeScale, the WaitForSecondsRealtime function would not be affected but WaitForSeconds would.
void Start()
{
StartCoroutine(waiter());
}
IEnumerator waiter()
{
//Rotate 90 deg
transform.Rotate(new Vector3(90, 0, 0), Space.World);
//Wait for 4 seconds
yield return new WaitForSecondsRealtime(4);
//Rotate 40 deg
transform.Rotate(new Vector3(40, 0, 0), Space.World);
//Wait for 2 seconds
yield return new WaitForSecondsRealtime(2);
//Rotate 20 deg
transform.Rotate(new Vector3(20, 0, 0), Space.World);
}
Wait and still be able to see how long you have waited:
3.With a coroutine and incrementing a variable every frame with Time.deltaTime.
A good example of this is when you need the timer to display on the screen how much time it has waited. Basically like a timer.
It's also good when you want to interrupt the wait/sleep with a boolean variable when it is true. This is where yield break; can be used.
bool quit = false;
void Start()
{
StartCoroutine(waiter());
}
IEnumerator waiter()
{
float counter = 0;
//Rotate 90 deg
transform.Rotate(new Vector3(90, 0, 0), Space.World);
//Wait for 4 seconds
float waitTime = 4;
while (counter < waitTime)
{
//Increment Timer until counter >= waitTime
counter += Time.deltaTime;
Debug.Log("We have waited for: " + counter + " seconds");
//Wait for a frame so that Unity doesn't freeze
//Check if we want to quit this function
if (quit)
{
//Quit function
yield break;
}
yield return null;
}
//Rotate 40 deg
transform.Rotate(new Vector3(40, 0, 0), Space.World);
//Wait for 2 seconds
waitTime = 2;
//Reset counter
counter = 0;
while (counter < waitTime)
{
//Increment Timer until counter >= waitTime
counter += Time.deltaTime;
Debug.Log("We have waited for: " + counter + " seconds");
//Check if we want to quit this function
if (quit)
{
//Quit function
yield break;
}
//Wait for a frame so that Unity doesn't freeze
yield return null;
}
//Rotate 20 deg
transform.Rotate(new Vector3(20, 0, 0), Space.World);
}
You can still simplify this by moving the while loop into another coroutine function and yielding it and also still be able to see it counting and even interrupt the counter.
bool quit = false;
void Start()
{
StartCoroutine(waiter());
}
IEnumerator waiter()
{
//Rotate 90 deg
transform.Rotate(new Vector3(90, 0, 0), Space.World);
//Wait for 4 seconds
float waitTime = 4;
yield return wait(waitTime);
//Rotate 40 deg
transform.Rotate(new Vector3(40, 0, 0), Space.World);
//Wait for 2 seconds
waitTime = 2;
yield return wait(waitTime);
//Rotate 20 deg
transform.Rotate(new Vector3(20, 0, 0), Space.World);
}
IEnumerator wait(float waitTime)
{
float counter = 0;
while (counter < waitTime)
{
//Increment Timer until counter >= waitTime
counter += Time.deltaTime;
Debug.Log("We have waited for: " + counter + " seconds");
if (quit)
{
//Quit function
yield break;
}
//Wait for a frame so that Unity doesn't freeze
yield return null;
}
}
Wait/Sleep until variable changes or equals to another value:
4.With a coroutine and the WaitUntil function:
Wait until a condition becomes true. An example is a function that waits for player's score to be 100 then loads the next level.
float playerScore = 0;
int nextScene = 0;
void Start()
{
StartCoroutine(sceneLoader());
}
IEnumerator sceneLoader()
{
Debug.Log("Waiting for Player score to be >=100 ");
yield return new WaitUntil(() => playerScore >= 10);
Debug.Log("Player score is >=100. Loading next Level");
//Increment and Load next scene
nextScene++;
SceneManager.LoadScene(nextScene);
}
5.With a coroutine and the WaitWhile function.
Wait while a condition is true. An example is when you want to exit app when the escape key is pressed.
void Start()
{
StartCoroutine(inputWaiter());
}
IEnumerator inputWaiter()
{
Debug.Log("Waiting for the Exit button to be pressed");
yield return new WaitWhile(() => !Input.GetKeyDown(KeyCode.Escape));
Debug.Log("Exit button has been pressed. Leaving Application");
//Exit program
Quit();
}
void Quit()
{
#if UNITY_EDITOR
UnityEditor.EditorApplication.isPlaying = false;
#else
Application.Quit();
#endif
}
6.With the Invoke function:
You can call tell Unity to call function in the future. When you call the Invoke function, you can pass in the time to wait before calling that function to its second parameter. The example below will call the feedDog() function after 5 seconds the Invoke is called.
void Start()
{
Invoke("feedDog", 5);
Debug.Log("Will feed dog after 5 seconds");
}
void feedDog()
{
Debug.Log("Now feeding Dog");
}
7.With the Update() function and Time.deltaTime.
It's just like #3 except that it does not use coroutine. It uses the Update function.
The problem with this is that it requires so many variables so that it won't run every time but just once when the timer is over after the wait.
float timer = 0;
bool timerReached = false;
void Update()
{
if (!timerReached)
timer += Time.deltaTime;
if (!timerReached && timer > 5)
{
Debug.Log("Done waiting");
feedDog();
//Set to false so that We don't run this again
timerReached = true;
}
}
void feedDog()
{
Debug.Log("Now feeding Dog");
}
There are still other ways to wait in Unity but you should definitely know the ones mentioned above as that makes it easier to make games in Unity. When to use each one depends on the circumstances.
For your particular issue, this is the solution:
IEnumerator showTextFuntion()
{
TextUI.text = "Welcome to Number Wizard!";
yield return new WaitForSeconds(3f);
TextUI.text = ("The highest number you can pick is " + max);
yield return new WaitForSeconds(3f);
TextUI.text = ("The lowest number you can pick is " + min);
}
And to call/start the coroutine function from your start or Update function, you call it with
StartCoroutine (showTextFuntion());

You were correct to use WaitForSeconds. But I suspect that you tried using it without coroutines. That's how it should work:
public void SomeMethod()
{
StartCoroutine(SomeCoroutine());
}
private IEnumerator SomeCoroutine()
{
TextUI.text = "Welcome to Number Wizard!";
yield return new WaitForSeconds (3);
TextUI.text = ("The highest number you can pick is " + max);
yield return new WaitForSeconds (3);
TextUI.text = ("The lowest number you can pick is " + min);
}

With .Net 4.x you can use Task-based Asynchronous Pattern (TAP) to achieve this:
// .NET 4.x async-await
using UnityEngine;
using System.Threading.Tasks;
public class AsyncAwaitExample : MonoBehaviour
{
private async void Start()
{
Debug.Log("Wait.");
await WaitOneSecondAsync();
DoMoreStuff(); // Will not execute until WaitOneSecond has completed
}
private async Task WaitOneSecondAsync()
{
await Task.Delay(TimeSpan.FromSeconds(1));
Debug.Log("Finished waiting.");
}
}
this is a feature to use .Net 4.x with Unity please see this link for description about it
and this link for sample project and compare it with coroutine
But becareful as documentation says that This is not fully replacement with coroutine

Bear in mind that coroutine stack ! If starting your coroutines in Update(), you might end up with loads of coroutines waiting inline and executing almost at the same time, just after your wait.
To avoid this, a good approach is to use a boolean, preventing from "stacking" coroutines :
bool isRunning = false;
IEnumerator MyCoroutine(){
isRunning = true;
print("started");
yield return new WaitForSeconds(3);
print("3 seconds elapsed");
yield return new WaitForSeconds(3);
print("more 3 seconds");
yield return new WaitForSeconds(2);
print("ended");
isRunning = false;
}
void Update(){
if (!isRunning) StartCoroutine(MyCoroutine());
}
Source : https://answers.unity.com/questions/309613/calling-startcoroutine-multiple-times-seems-to-sta.html

here is more simple way without StartCoroutine:
float t = 0f;
float waittime = 1f;
and inside Update/FixedUpdate:
if (t < 0){
t += Time.deltaTIme / waittime;
yield return t;
}

Use async and await
public void Start() {
doTask();
}
async void doTask() {
Debug.Log("Long running task started");
// wait for 5 seconds, update your UI
await Task.Delay(TimeSpan.FromSeconds(5f));
// update your UI
Debug.Log("Long running task has completed");
}

//Here is a example of some of my code to wait in Unity I have made using a value and update dating it every update, once it its the value the if statement is looking for it will run the task.
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class EnterCarCollider : MonoBehaviour
{
public GameObject player;
//Calls & Delcares vehicle objects
public GameObject Camera;
public VehicleControl ascript;
public Collider enterDriverCollider;
public Collider parkBreakCollider;
public GameObject enterVehicleDriverToolTip;
public int forStayInTime = 32;
public int timeInActiveTriggeredCollider;
private void Start()
{
ascript = GetComponent<VehicleControl>();
timeInActiveTriggeredCollider = 0;
}
private void OnTriggerStay(Collider other)
{
if (forStayInTime <= timeInActiveTriggeredCollider)
{
if (Input.GetKey(KeyCode.E))
{
ascript.enabled = !ascript.enabled;
Camera.active = true;
player.active = false;
enterDriverCollider.enabled = false;
parkBreakCollider.enabled = false;
}
// TODO: Enter car message
enterVehicleDriverToolTip.active = true;
}
timeInActiveTriggeredCollider++;
}
private void OnTriggerExit(Collider other)
{
enterVehicleDriverToolTip.active = false;
timeInActiveTriggeredCollider = 0;
}
private void Update()
{
if (enterDriverCollider.enabled is false)
{
timeInActiveTriggeredCollider = 0;
}
}
}

NavMesh Agent override rotation

I have enemies that patrol to different waypoints using NavMesh Agent I want when the enemy reach the next waypoint to have the same rotation as that waypoint.
Here is the code:
void Update ()
{
if (agent.remainingDistance < 0.1)
{
// tried to stop the agent so I can override it's rotation, doesn't work
agent.Stop();
// Give him the desired rotation
transform.rotation = wayPoints[curretPoint].rotation;
if (curretPoint < wayPoints.Length -1)
{
curretPoint++;
}
else
{
curretPoint = 0;
}
// make him wait for a fixed amount of time
patrolTimer += Time.deltaTime;
if (patrolTimer >= patrolWait)
{
patrolTimer = 0;
agent.SetDestination (wayPoints[curretPoint].position);
agent.Resume ();
}
}
}
The problem is that he keeps rotating back and forth very quickly, I can't get teh desired effect that I want.

Try setting Angular Speed of NavMesh Agent to 0.
Edit:
That should work:
// make him wait for a fixed amount of time
patrolTimer += Time.deltaTime;
if (patrolTimer >= patrolWait)
{
if (curretPoint < wayPoints.Length -1)
{
curretPoint++;
}
else
{
curretPoint = 0;
}
patrolTimer = 0;
agent.SetDestination (wayPoints[curretPoint].position);
agent.Resume ();
}

This is how I handled it:
Instead of doing agent.Stop(); and agent.Resume(); I simply set its speed to 0 and used transform.Rotate to rotate the character.