为什么对象的缩放比例一直在不停地上下变化？

Question

What i want to do is when i press F once on the first script and it's true to display the object then start the coroutine to change the object scale on the second object.

The problem is that it's scaling the object non stop up and down and i want it to scale it once up and if i will press F again to not displaying the object scale it back down once.

The first script where i press on F:

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class DroidMove : MonoBehaviour
{
    public GameObject droid;
    public ChangeScale changeScale;

    private float distance;
    private Camera cam; 

    private void Start()
    {
        cam = GetComponent<Camera>();
        distance = Vector3.Distance(cam.transform.position, droid.transform.position);
        droid.SetActive(false);
    }

    private void Update()
    {
        if (Input.GetKeyDown(KeyCode.F))
        {
            droid.SetActive(!droid.activeInHierarchy);
            if (droid.activeInHierarchy == true)
            {
                changeScale.Scale();
            }
        }
    }
}

The second script that scale the object:

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class ChangeScale : MonoBehaviour
{
    public GameObject objectToScale;

    private float _currentScale = InitScale;
    private const float TargetScale = 1.1f;
    private const float InitScale = 0f;
    private const int FramesCount = 100;
    private const float AnimationTimeSeconds = 2;
    private float _deltaTime = AnimationTimeSeconds / FramesCount;
    private float _dx = (TargetScale - InitScale) / FramesCount;
    private bool _upScale = true;

    private IEnumerator Breath()
    {
        while (true)
        {
            while (_upScale)
            {
                _currentScale += _dx;
                if (_currentScale > TargetScale)
                {
                    _upScale = false;
                    _currentScale = TargetScale;
                }
                objectToScale.transform.localScale = Vector3.one * _currentScale;
                yield return new WaitForSeconds(_deltaTime);
            }

            while (!_upScale)
            {
                _currentScale -= _dx;
                if (_currentScale < InitScale)
                {
                    _upScale = true;
                    _currentScale = InitScale;
                }
                objectToScale.transform.localScale = Vector3.one * _currentScale;
                yield return new WaitForSeconds(_deltaTime);
            }
        }
    }

    public void Scale()
    {
        StartCoroutine(Breath());
    }
}

Answer 1

While I can't test it out myself, I made some minor changes that I believe should give you the desired behaviour. The first script becomes:

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class DroidMove : MonoBehaviour
{
    public GameObject droid;
    public ChangeScale changeScale;

    private float distance;
    private Camera cam; 

    private void Start()
    {
        cam = GetComponent<Camera>();
        distance = Vector3.Distance(cam.transform.position, droid.transform.position);
        droid.SetActive(false);
    }

    private void Update()
    {
        if (Input.GetKeyDown(KeyCode.F))
        {
            changeScale.Scale();
        }
    }
}

The second script becomes:

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class ChangeScale : MonoBehaviour
{
    public GameObject objectToScale;

    private float _currentScale = InitScale;
    private const float TargetScale = 1.1f;
    private const float InitScale = 0f;
    private const int FramesCount = 100;
    private const float AnimationTimeSeconds = 2;
    private float _deltaTime = AnimationTimeSeconds / FramesCount;
    private float _dx = (TargetScale - InitScale) / FramesCount;
    private bool _upScaling = false;
    private bool _downScaling = false;

    private IEnumerator ScaleUp()
    {
        _upScaling = true;
        while (_upScaling)
        {
            _currentScale += _dx;
            if (_currentScale > TargetScale)
            {
                _upScaling = false;
                _currentScale = TargetScale;
            }
            objectToScale.transform.localScale = Vector3.one * _currentScale;
            yield return new WaitForSeconds(_deltaTime);
        }
    }

    private IEnumerator ScaleDown()
    {
        _downScaling = true;
        while (_downScaling)
        {
            _currentScale -= _dx;
            if (_currentScale < InitScale)
            {
                _downScaling = false;
                _currentScale = InitScale;
                droid.SetActive(false);
            }
            objectToScale.transform.localScale = Vector3.one * _currentScale;
            yield return new WaitForSeconds(_deltaTime);
        }
    }

    public void Scale(bool scaleUp)
    {
        if (!droid.activeInHierarchy) {
            droid.SetActive(true);
            StartCoroutine(ScaleUp());
        }

        if (_downScaling)
            StartCoroutine(ScaleUp());
        else
            StartCoroutine(ScaleDown());
    }
}

I basically made 2 different routines; one that scales up and one that scales down. When you press F, I adapt the active state of the object, and depending on that state the right coroutine is called.