Mathf.Lerp doesn't work on light object's value change

Try

 myLight.range = Mathf.Lerp(myLight.range , maximum, Time.deltaTime * smooth);

Lerp as a function goes from Point A to Point B by a value of 0 to 1.

In you line, inside the Update loop

 myLight.range = Mathf.Lerp(minimum, maximum, Time.deltaTime * smooth);

suppose minimum = 0.2; maximum = 0.8;

and Time.deltaTime * smooth = 0.5; //i know its much less

Every single update your range will become

range = minimum + (maximum - minimum) * 0.5f;

And the next update you will start all over again, never reaching the target

Usually in lerps you want to feed the Point A the actual value that is chaning

I rewrote your code a bit. First, I changed your Update loop entirely. Next, I moved your code from OnTriggerStay to OnTriggerEnter with coroutine. The reason is that you should check for inputs (GetKey) in Update loop, not in FixedUpdate. OnTriggerStay acts as FixedUpdate, while OnTriggerEnter with coroutine (with while loop yielding null) works as Update. Here's the script:

 using System.Collections;
 using System.Collections.Generic;
 using UnityEngine;
 
 public class tuomvii : MonoBehaviour
 {
     public Animator anim;
     public bool lidCheck;
     public Light myLight;
     public float minimum = 2.0f;
     public float maximum = 8.0f;
     public float smooth = 2.0f;
     
     private float t;
     private Coroutine co = null;
     
     void Start()
     {
         anim = GetComponent<Animator>();
         lidCheck = false;
     }    
     
     void Update()
     {
         t += Time.deltaTime * smooth * (-1 + 2*System.Convert.ToInt32(lidCheck));
         t = Mathf.Clamp01(t);
         myLight.range = Mathf.Lerp(minimum, maximum, t);
     }
     
     void OnTriggerEnter (Collider other)
     {
         if (other.gameObject.CompareTag("Player"))
         {
             co = StartCoroutine(LightCoroutine());
         }
     }
     
     void OnTriggerExit(Collider other)
     {
         if (other.gameObject.CompareTag("Player"))
         {
             StopCoroutine(co);
         }
     }
         
     IEnumerator LightCoroutine()
     {
         while (true)
         {
             if (Input.GetKey(KeyCode.E))
             {
                 anim.Play("openlid");
                 lidCheck = true;
             }
             if (Input.GetKey(KeyCode.R))
             {
                 anim.Play("closelid");
                 lidCheck = false;
             }
             yield return null;
         }
     }
 }

Hello there,

If you don't want to use arbitrary speeds and values, you could implement something like this:

     private Coroutine cor_turnOnOrOff = null;
     public float f_transitionDuration = 4.0f;
     public Light ref_myLight = null;
 
     private void OnTriggerStay(Collider other)
     {
         if (other.gameObject.tag == "Player")
         {
             if (Input.GetKey(KeyCode.E))
             {
                 TurOnOrOff(true);
             }
             if (Input.GetKey(KeyCode.R))
             {
                 TurOnOrOff(false);
             }
         }
     }
 
     public void TurOnOrOff(bool turnOn)
     {
         if (cor_turnOnOrOff != null)
             StopCoroutine(cor_turnOnOrOff);
 
         cor_turnOnOrOff = StartCoroutine(TurnOnOrOffCoroutine(turnOn));
     }
 
     private IEnumerator TurnOnOrOffCoroutine(bool turnOn)
     {
         float startValue = ref_myLight.range;
         float targetValue = 0.0f;
         float timer = 0.0f;
 
         if (turnOn)
         {
             anim.Play("openlid");
             targetValue = maximum;
         }
         else
         {
             anim.Play("closelid");
             targetValue = minimum;
         }
 
         while (timer < f_transitionDuration)
         {
             timer += Time.deltaTime;
             float t = timer / f_transitionDuration;
             t = t * t * t * (t * (6f * t - 15f) + 10f);
             ref_myLight.range = Mathf.Lerp(startValue, targetValue, t);
             yield return null;
         }
         yield return null;
     }

This might look a little complicated, but it isn't really. All you have to do is call TurnOnOrOff(true); when you want the lamp to turn on, and TurnOnOrOff(false); when you want it off. The transition then occurs over however many seconds you set f_transitionDuration, instead of setting an arbitrary speed.

The line t = t * t * t * (t * (6f * t - 15f) + 10f); is just a smoothing algorithm. If you don't like this one, you can pick another one from this page; keep the one that looks the best for your project!

I hope that helps!

Cheers,

~LegendBacon