- Home /
Gameobject moving faster at higher framerates? Using Time.deltaTime
For whatever reason my character is moving faster at higher framerates even though I execute Time.deltaTime. Sorry for it being so long though.
To explain this further, upon building my program, it will move a lot fast if you set the settings to "Fast" rather than "Fantastic". The higher the graphical setting the slow it moves, "Fantastic" will make it move as it's supposed to move, leaving me to the conclusion that it's due to higher framerates.
I tried looking for ways to make it visible upon clicking, but I couldn't find any kind of code for that. Could someone write a reply explaining how to insert that? Thanks :)
using UnityEngine;
using System.Collections;
public class AvatarMovement : MonoBehaviour {
public Texture leftRun01; //First texture in left running animation.
public Texture leftRun02; //Second texture in left running animaation.
public Texture leftRun03; //Third texture in left running animation.
public Texture leftRun04; //Fourth texture in left running animation.
public Texture rightRun01; //First texture in right running animation.
public Texture rightRun02; //Second texture in right running animation.
public Texture rightRun03; //Third texture in right running animation.
public Texture rightRun04; //Fourth texture in right running animation.
public float AnimationInterval; //Value in seconds in between each texture when running animations.
public float verticalRaycastLength; //Value of a default vertical raycast.
public float horizontalRaycastLength; //Value of a default horizontal raycast.
public float JumpSpeed; //Value of the height of the players jump.
public float WalkingSpeed; //Walking speed of the player.
public bool AssistWalk = true; //Allow walking assist? Refer to WalkRight and WalkLeft methods.
private bool runRightAnimation = false; //Run right animation?
private bool runLeftAnimation = true; //Run left animation?
private bool isJumping = false; //Is the player currently in the air?
private bool AllowJumpMovement; //Can the player move in the air?
public bool Walk = false; //Forces movement.
private Vector3 StartPosition; //Coordinates of where the player spawned.
void Start()
{
StartPosition = transform.position; //Saves coordinates of where the player spawned.
Debug.Log (StartPosition);
} //Run when gameobject with script is instantiated.
void Update()
{
ForceWalkTrigger forceWalkTrigger = GameObject.Find("ForceWalkTrigger").GetComponent<ForceWalkTrigger>();
if (Input.GetKeyDown(KeyCode.R)) //Respawns the player.
{
if (Application.isEditor) //Only run if we're using the editor.
{
transform.position = StartPosition; //Teleports player to starting position.
}
}
if (Input.GetKey (KeyCode.Escape))
{
Application.Quit(); //Quits application.
}
if (Input.GetKey("d"))
{
runRightAnimation = true; //Code that tells the script it's.
runLeftAnimation = false; //supposed to run right animation.
RaycastHit Target;
if (AllowJumpMovement || Walk) //Allows the player to move while not grounded.
{
WalkRight();
}
if (Physics.Raycast(transform.position, -Vector3.right, out Target, horizontalRaycastLength))
{
if (Target.collider.gameObject.name == "Crate") //Changes walking speed if pushing a crate.
{
WalkingSpeed = 0.3f;
}
else if(Target.collider.gameObject.name == "Collider") //Resets speed if not pushing a crate.
{
WalkingSpeed = 0.5f;
}
if (AssistWalk) //Assists in walking up cliffs.
{
rigidbody.AddForce(Vector3.up * 3000 * JumpSpeed * Time.deltaTime); //This has been implemented to make it less "bumpy" and a lot more smooth.
}
}
else
{
WalkingSpeed = 0.5f; //Resets walking speed.
}
}
else if (Input.GetKey("a"))
{
runRightAnimation = false; //Code that tells the script it's
runLeftAnimation = true; //supposed to run the left animation.
RaycastHit Target;
if (AllowJumpMovement || Walk) //Allows the player to move while not grounded.
{
WalkLeft();
}
if (Physics.Raycast(transform.position, Vector3.right, out Target, horizontalRaycastLength))
{
if (Target.collider.gameObject.name == "Crate") //Changes walking speed if pushing a crate.
{
WalkingSpeed = 0.3f;
}
else if(Target.collider.gameObject.name == "Collider") //Resets speed if not pushing a crate.
{
WalkingSpeed = 0.5f;
}
if (AssistWalk) //Assists in walking up cliffs.
{
rigidbody.AddForce(Vector3.up * 3000 * JumpSpeed * Time.deltaTime); //This has been implemented to make it less "bumpy" and a lot more smooth.
}
}
else
{
WalkingSpeed = 0.5f; //Resets walking speed.
}
}
if (Input.GetKeyDown("w")) //Makes the character jump.
{
Jump ();
}
else if (Input.GetKeyDown("space")) //Also makes the character jumps. Else if statement to make sure you can't doublejump.
{
Jump();
}
if (runLeftAnimation) //True if we're facing left.
{
if (!DontRunLeft) //Added to make sure we don't run the animation several times at once.
{
StartCoroutine(LeftAnimation()); //Starts the running animation. Refer to LeftAnimation method.
}
}
else //Ran if we're not facing left.
{
if (!DontRunRight) //Added to make sure we don't run the animation several times at once.
{
StartCoroutine(RightAnimation()); //Starts the running animation. Refer to RightAnimation method.
}
}
} //Run every frame.
void WalkRight()
{
if (AssistWalk)
{
transform.position -= new Vector3(WalkingSpeed / 10, WalkingSpeed / -10, 0 * Time.deltaTime); //Disallows the player to "glitch" while walking up hills.
}
else
{
transform.position -= new Vector3(WalkingSpeed / 10, 0, 0 * Time.deltaTime);
}
} //Code for walking right.
void WalkLeft()
{
if (AssistWalk)
{
transform.position += new Vector3(WalkingSpeed / 10, WalkingSpeed / 10, 0 * Time.deltaTime); //Disallows the player to "glitch" while walking up hills.
}
else
{
transform.position += new Vector3(WalkingSpeed / 10, 0, 0 * Time.deltaTime);
}
} //Code for walking left.
private RaycastHit Target;
void Jump()
{
if (!isJumping)
{
if (Physics.Raycast(transform.position, -Vector3.up, out Target, verticalRaycastLength))
{
rigidbody.AddForce(Vector3.up * 100000 * JumpSpeed * Time.deltaTime);
}
}
} //Code for jumping.
void OnCollisionStay()
{
isJumping = false;
if (Physics.Raycast(transform.position, -Vector3.up, verticalRaycastLength))
{
AllowJumpMovement = true;
}
else
{
AllowJumpMovement = false;
}
} //Run every frame collider is touching another collider.
void OnCollisionExit()
{
isJumping = true;
} //Run when this collider stops touching another collider.
private bool DontRunLeft = false; //Variable to determine whether we can run the left animation loop or not. Used to make sure we don't run several loops at once.
IEnumerator LeftAnimation()
{
while (true) //This will allow us to break out of the animation, in case we suddenly change direction.
{
DontRunLeft = true; //This will block the script from running the same animation over and over again at the same time.
if (!runLeftAnimation) //If we suddenly changed direction, this will run code to snap out of the animation loop.
{
DontRunLeft = false; //We can now enter the animation loop again.
break; //Breaks out of the animation loop.
}
this.renderer.material.mainTexture = leftRun02; //Changes texture to the second texture in our loop.
yield return new WaitForSeconds(AnimationInterval); //Yields the entire loop for X amounts of seconds. Check inspector for details.
if (!runLeftAnimation) //If we suddenly changed direction, this will run code to snap out of the animation loop.
{
DontRunLeft = false; //We can now enter the animation loop again.
break; //Breaks out of the animation loop.
}
this.renderer.material.mainTexture = leftRun03; //Changes texture to the third texture in our loop.
yield return new WaitForSeconds(AnimationInterval); //Yields the entire loop for X amounts of seconds. Check inspector for details.
if (!runLeftAnimation) //If we suddenly changed direction, this will run code to snap out of the animation loop.
{
DontRunLeft = false; //We can now enter the animation loop again.
break; //Breaks out of the animation loop.
}
this.renderer.material.mainTexture = leftRun04; //Changes texture to the fourth texture in our loop.
yield return new WaitForSeconds(AnimationInterval); //Yields the entire loop for X amounts of seconds. Check inspector for details.
if (!runLeftAnimation) //If we suddenly changed direction, this will run code to snap out of the animation loop.
{
DontRunLeft = false; //We can now enter the animation loop again.
break; //Breaks out of the animation loop.
}
this.renderer.material.mainTexture = leftRun01; //Changes the texture back to the first one in our loop.
yield return new WaitForSeconds(AnimationInterval); //Yields the entire loop for X amounts of seconds. Check inspector for details.
DontRunLeft = false; //We can now enter the animation loop again.
break; //Breaks out of the animation loop.
}
} //Code for left running animation.
private bool DontRunRight = false; //Variable to determine whether we can run the right animation loop or not. Used to make sure we don't run several loops at once.
IEnumerator RightAnimation()
{
while (true) //This will allow us to break out of the animation, in case we suddenly change direction.
{
DontRunRight = true; //This will block the script from running the same animation over and over again at the same time.
if (!runRightAnimation) //If we suddenly changed direction, this will run code to snap out of the animation loop.
{
DontRunRight = false; //We can now enter the animation loop again.
break; //Breaks out of the animation loop.
}
this.renderer.material.mainTexture = rightRun02; //Changes texture to the second texture in our loop.
yield return new WaitForSeconds(AnimationInterval); //Yields the entire loop for X amounts of seconds. Check inspector for details.
if (!runRightAnimation) //If we suddenly changed direction, this will run code to snap out of the animation loop.
{
DontRunRight = false; //We can now enter the animation loop again.
break; //Breaks out of the animation loop.
}
this.renderer.material.mainTexture = rightRun03; //Changes texture to the third texture in our loop.
yield return new WaitForSeconds(AnimationInterval); //Yields the entire loop for X amounts of seconds. Check inspector for details.
if (!runRightAnimation) //If we suddenly changed direction, this will run code to snap out of the animation loop.
{
DontRunRight = false; //We can now enter the animation loop again.
break; //Breaks out of the animation loop.
}
this.renderer.material.mainTexture = rightRun04; //Changes texture to the fourth texture in our loop.
yield return new WaitForSeconds(AnimationInterval); //Yields the entire loop for X amounts of seconds. Check inspector for details.
if (!runRightAnimation)
{
DontRunRight = false; //We can now enter the animation loop again.
break; //Breaks out of the animation loop.
}
this.renderer.material.mainTexture = rightRun01; //Changes the texture back to the first one in our loop.
yield return new WaitForSeconds(AnimationInterval); //Yields the entire loop for X amounts of seconds. Check inspector for details.
DontRunRight = false; //We can now enter the animation loop again.
break; //Breaks out of the animation loop.
}
} //Code for right running animation.
}
Answer by PAEvenson · Feb 12, 2013 at 02:30 AM
Another issue is when you are moving the position:
transform.position -= new Vector3(WalkingSpeed / 10, WalkingSpeed / -10, 0 * Time.deltaTime);
you're multiplying 0 * Time.deltaTime(which will always be 0) for Z and not multiplying X and Y by Time.deltaTime.
This is true. Plus, if your update loop is occuring more frequently (as it will at higher framerates), then you're going to be affecting the transform's position more often. Either way (since delta time will fix it), the best way to do this would be to multiply the entire Vector by Time.deltaTime.
transform.position -= new Vector3(WalkingSpeed / 10, WalkingSpeed / -10, 0) * Time.deltaTime;
Ah yeah, I didn't spot that. Thanks for pointing it out, I'll go right ahead and fix it :)
Answer by iwaldrop · Feb 12, 2013 at 02:27 AM
That's a lot of code to sift through, but I think that, but on line 60, for instance, you do a AddForce in an update loop. This is bad. Do physics stuff in FixedUpdate. Additionally, you should only be making calls to methods like Jump() from FixedUpdate.
http://docs.unity3d.com/Documentation/ScriptReference/MonoBehaviour.FixedUpdate.html
Yeah, I actually knew this, honest mistake on my part. Thanks for pointing it out :)
Just like to add that Jump can and should be called from Update since it's a one time event. All forces that are applied over multiple frames should be applied in FixedUpdate. Also one time events like Just shouldn't be scaled with Time.deltaTime since that's only useful when doing something over time and to make it time based ins$$anonymous$$d of frame based.
Furthermore for one time events there are other Force$$anonymous$$odes available like Impulse and VelocityChange.
The default mode Force and the mode Acceleration should only be used in FixedUpdate.
Your answer
Follow this Question
Related Questions
Multiple Cars not working 1 Answer
Distribute terrain in zones 3 Answers
Playing clock ticking sound 1 Answer
Only able to Hit the Z key once every 10 seconds 1 Answer
Do i need to use Time.Deltatime while using mouse axes for rotation? 1 Answer