从我所看到的，您只需要缓存值，当调用新的更新时，只需检查值是否更改

// Somewhere have a field that saves previous state
private bool _wasPaused;

void Update()
{
    SwitchCameras();
}

private void SwitchCameras()
{
    if (_wasPaused != PauseController.isPaused)
    {
        if (PauseController.isPaused)
        {
            gameCam.enabled = false;
            mainCam.cullingMask = pausedLayerMask;
        }
        else
        {
            gameCam.enabled = true;
            mainCam.cullingMask = originalLayerMask;
        }
    }
    _wasPaused = PauseController.isPaused;
}

我们可以使用一个私有变量和一个属性。这样我们就可以检查属性何时改变值，并且在值改变时只处理一个操作。
很快，这应该是一种实现你想要做的事情的方法：

private bool _isInFront;
public bool isInFront
{
    get => _isInFront;
    set
    {
        if ( _isInFront == value )
            return;
        _isInFront = value;
        InView();
    }

}

private void Update ()
{
    isInFront = InFrontOfScreen(); //This is a condition 
    Pausing();
}

问题是gameCam.enabled和mainCam应该只在bool isPaused改变时调用一次
在这种情况下（一般情况下），您根本不应该轮询Update中的检查标志，而是让您的代码React式事件驱动，并且只在值实际更改时做出一次React。
所以在你的第一个剧本里我会加一个

public event Action<bool> pauseStateChanged;

无论何时设置isPaused的状态，都要相应地调用事件，并在负责类中执行更改检查，而不是所有侦听器都必须自己跟踪它

...
// Check makes sure the event is really only called when the state is changed
if(!isPaused)
{
    isPaused = true;
    pauseStateChanged?.Invoke(true);
}

然后在其他脚本中附加一个侦听器，该侦听器仅在调用事件时-〉状态实际更改时才被调用

private void Start()
{
    // start listening to the event
    PauseController.pauseStateChanged += SwitchCameras;

    // initially call the callback once with the current state
    SwitchCameras(PauseController.isPaused);
}

private void OnDestroy()
{
    // remove the listener once not needed anymore to avoid exceptions
    PauseController.pauseStateChanged -= SwitchCameras;
}

private void SwitchCameras(bool isPaused)
{
    gameCam.enabled = !isPaused;
    // Using a ternary here makes this way easier to read imho
    mainCam.cullingMask = isPaused ? pausedLayerMask : originalLayerMask;
}

遵循同样的原则，您还可以使第一个脚本的其余部分以相同的方式React，而不是在Update中调用每一帧的内容，我可能会使用Coroutine并执行以下操作

private Coroutine routine;

void Update()
{     
    var currentIsInFront = InFrontOfScreen();

    // Did state change?
    if(isInFront != currentIsInFront)
    {
        if(routine != null)
        {
            StopCoroutine(routine);
        }

        isInFront = currentIsInFront;
        routine = StartCoroutine(PauseRoutine);       
    }
}

private IEnumerator PauseRoutine()
{
    var newPausedState = !isInFront;

    if(isPaused != newPausedState)
    {
        var delay = isInFront ? maxInViewTime : maxOutOfViewTime;

        yield return new WaitForSecondsRealtime(delay);

        isPaused = newPausedState;  

        pauseStateChanged?.Invoke(newPausedState);

        Time.timeScale = newPausedState ? 0f : 1f;
    }
}