How to make a game frame rate independent in Unity?

So, I have a Unity game intended for mobile use, but the problem that I am currently facing is that it performs differently on seperate devices, with some it goes super slow, and with others it goes super fast. I just want my game to run at the same speed as it did in the Unity editor, in the downloaded Google Play version. One of the solutions I found online was to make it frame rate independent, so my question is: How can I make the following script frame rate independent?

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class playerScript : MonoBehaviour
{
public GameObject Player;
public Sprite piranha_mouthOpen;
public Sprite piranha_mouthClosed;
public float playerPositionY;
public float speed = 0;
public float deltaTime;
public float deltaTimeTouch;
public float passiveSpeed = 0;
public GameObject UpperBorder;
public GameObject LowerBorder;
public bool playerEliminated;
public GameObject UpperObstacle;
public GameObject LowerObstacle;
private Rigidbody2D rb;
public float normalGravityScale = 1.0f; // the default gravity scale for the object
public float collisionGravityScale = 5.0f;
private Collider2D col;
public bool gameStart;
// Speed of rotation in degrees per second
public float rotationSpeed = 120f;
// Target rotation on the Z-axis in degrees
public float targetRotation = 55f;
// Threshold for considering the rotation "close enough" to the target
public float rotationThreshold = 0.1f;
// Target rotation on the Z-axis in degrees (negative)
public float negativeTargetRotation = -55f;
public void OnTriggerEnter2D(Collider2D col)
{
if (col.gameObject.name == "UpperBorder")
{
//playerEliminated = true;
Debug.Log("gameObject.SetActive(false)");
}
if (col.gameObject.name == "LowerBorder")
{
//playerEliminated = true;
Debug.Log("gameObject.SetActive(false)");
}
if (col.gameObject.name == "UpperObstacle")
{
playerEliminated = true;
rb.constraints = RigidbodyConstraints2D.None;
rb.gravityScale = collisionGravityScale;
col.isTrigger = false;
}
if (col.gameObject.name == "LowerObstacle")
{
playerEliminated = true;
rb.constraints = RigidbodyConstraints2D.None;
rb.gravityScale = collisionGravityScale;
col.isTrigger = false;
}
}
// Start is called before the first frame update
void Start()
{
playerEliminated = false;
transform.position = new Vector3 (0, 0, 0);
transform.Rotate(0, 0, 0);
playerPositionY = transform.position.y;
deltaTime = 0;
StartCoroutine(changeSprite());
rb = GetComponent<Rigidbody2D>();
rb.gravityScale = normalGravityScale;
col = GetComponent<Collider2D>();
gameStart = false;
}
IEnumerator changeSprite()
{
while (playerEliminated == false)
{
yield return new WaitForSeconds(0.25f);
Player.gameObject.GetComponent<SpriteRenderer>().sprite = piranha_mouthClosed;
yield return new WaitForSeconds(0.25f);
Player.gameObject.GetComponent<SpriteRenderer>().sprite = piranha_mouthOpen;
}
}
// Update is called once per frame
void Update()
{
if (playerEliminated == false)
{
if (gameStart == true)
{
// movement
if (Input.touchCount > 0)
{
Touch touch = Input.GetTouch(0);
if (touch.phase == TouchPhase.Began)
{
speed = 0.1f;
deltaTimeTouch = 1;
deltaTime = 0;
}
else if (touch.phase == TouchPhase.Moved)
{
deltaTimeTouch += 0.01f;
speed = speed + 0.001f * deltaTimeTouch;
// * 35
}
else if (touch.phase == TouchPhase.Ended)
{
speed = 0;
deltaTimeTouch = 1;
}
playerPositionY = transform.position.y;
transform.position = new Vector3(0,playerPositionY - speed, 0);
if (Mathf.Abs(transform.rotation.eulerAngles.z - negativeTargetRotation) > rotationThreshold)
{
// Rotate towards the target
float step = rotationSpeed * Time.deltaTime;
transform.rotation = Quaternion.RotateTowards(transform.rotation, Quaternion.Euler(0, 0, negativeTargetRotation), step);
}
}
else if (Input.touchCount == 0 )
{
deltaTime += 0.001f;
speed += 0.008f * deltaTime;
// * 35
playerPositionY = transform.position.y;
transform.position = new Vector3(0,playerPositionY + speed, 0);
// Rotation (90 degrees)
if (Mathf.Abs(transform.rotation.eulerAngles.z - targetRotation) > rotationThreshold)
{
// Rotate towards the target
float step = rotationSpeed * Time.deltaTime;
transform.rotation = Quaternion.RotateTowards(transform.rotation, Quaternion.Euler(0, 0, targetRotation), step);
}
}
//borders
if (transform.position.y >= 20.5f)
{
transform.position = new Vector3(0, 20.5f, 0);
}
if (transform.position.y <= -20f)
{
transform.position = new Vector3(0, -20f, 0);
}
}
}
if (gameStart == false)
{
if (Input.touchCount > 0 )
{
Touch touch = Input.GetTouch(0);
if (touch.phase == TouchPhase.Began)
{
speed = 0.1f;
deltaTimeTouch = 1;
deltaTime = 0;
gameStart = true;
}
}
}
}
}

Lets cover this question a bit broader, so that we can see the evolution of how programmers end up where they are:

For start, imagine that your character can move 100 units every tick (unit can be meter, pixel, ... depends on context). Your game is currently running in 60 FPS (frames per second), which would lead to 6000 units movement (100*60 = 6000). But we don't want to move this character 6000 units every second, instead we want to move it only those 100 units.

What is the number you need to get, so that the character can move "just a little" every tick?

We must multiply current step size with a "fraction" of the second, and its size depends on the framerate as:

1/60 ~ 0.016666666666

How would you implement that?

void Update()
{
    float FPS = 60f;                   // 60 frames per second
    float stepModifier = 1 / FPS;      // 1/60 of frame

    float stepSize = 100;              // 100 units

    // 1.6666 units in this frame
    float stepSizeInCurrentFrame = stepSize * stepModifier; 

    MakeStep(stepSizeInCurrentFrame);  
}

void MakeStep(float stepSize) { }

This is nice, but what to do if my FPS changes all the time and is not strictly 60 fps? Unity (and usually all game engines) have mechanism to get "time since last frame" ~ how long did it take since last frame has finished. This variable is genuinelly called delta (coming from math), as it is difference:

var delta = currentTime - previousFrameTime;

In Unity this can be obtained as:

var delta = Time.deltaTime;

This way we can update our code and in all places where we need to move only "fraction of actual movement", we will multiply the movement size:

void Update()
{
    float stepSize = 100;              // 100 units (same as before)

    // Resulting value depends on time since last frame
    float stepSizeInCurrentFrame = stepSize * Time.deltaTime; 

    MakeStep(stepSizeInCurrentFrame);  
}

void MakeStep(float stepSize) { }

More about the deltaTime can be found in official documentation.

Unity has it's own Time.deltaTime, which is used to make the games frame rate independent, I would suggest you to use Unity's built in Time.deltaTime instead of having of your own, since your deltaTime variable is defined in class and is getting updated in the Update() or some other method, it is not frame rate independent.

When you apply your movement, instead of the Update method you can use the FixedUpdate method. You can read more about the difference in the links.

A quick answer why this will help you is that, the Update method it runs as fast as your device can handle. What that means is that if you run the game with a good hardware that runs with more than 70fps, that means the Update method will be executed 70 times per second and if your hardware is not good enough it might be running with 40fps and so on. That's why your speed will be different based on the device.

On the other hand FixedUpdate is guarantee to run the same amount of fps which I think is 50fps in any device and is recommended to use this method when you have to apply any kind of physics.

Also you can set manually the amount of fps your game will run like this:

void Start()
{      
Application.targetFrameRate = 60;
}