Есть ли простой и эффективный способ проверить точный кадр, в котором логическое значение меняется с true на false или наоборот, а затем вызвать функцию?

Есть ли простой и эффективный способ проверить точный кадр, в котором логическое значение меняется с true на false или наоборот, а затем вызвать функцию?

1. Классический способ сделать это — сохранить значение в логическом поле, а затем сравнить новое значение со старым значением в следующем кадре:

   bool _oldValue;
   
   void Update() {
       bool newValue = your calculations;
       if (newValue != _oldValue) {
           _oldValue = newValue;
           YourFunction();
       }
   }
   
   void YourFunction() { }
   

   Это правильный способ сделать это, когда вся ваша логика находится в одном классе. Если в какой-то момент у вас появится много таких переменных и это станет беспорядок, вам следует рассмотреть возможность рефакторинга вашего кода на несколько классов.

2. Вы можете использовать свойство:

   bool _value;
   bool Value {
       set {
           if (_value == value)
              return;
   
           _value = value;
           YourFunction();
       }
   }
   
   void YourFunction() { }
   
   void Update() {
       Value = your calculations;
   }
   

   На первый взгляд этот подход кажется изящным, но проблема в том, что программисты обычно не ожидают побочных эффектов от свойств. Вызов функции, которая меняет что-то другое, является побочным эффектом. Вы все еще можете использовать этот подход до тех пор, пока свойство не будет открыто как public. Но в реальном проекте, где вместе работают несколько программистов, лучше этого не делать.

3. Также возможно инкапсулировать значение в классе:

   public class Value {
      bool _value;
      public bool HasChanged { get; private set; }
      public Value(bool value = false) => _value = value;
      public void Update(bool newValue) {
          IsChanged = newValue != _value;
          _value = newValue;
      }
   }
   

   но, как вы можете видеть ниже, это само по себе не дает много преимуществ с точки зрения кода:

   Value _myValue = new();
   
   void Update() {
       bool newValue = your calculations;
       _myValue.Update(newValue);
       if (_myValue.IsChanged) {
           YourFunction();
       }
   }
   

   Другими словами, введение такого универсального класса только для хранения и проверки переменной не имеет смысла. Это одинаковое количество строк кода, ясности это не добавляет и т.д.

4. Если в вашем коде есть несколько классов, вы можете начать использовать события. Это также правильный способ сделать это, когда некоторые API предоставляют вам события. Вот реализация простого события C#:

   public class Value {
       bool _value;
       public event Action ValueChanged;
       public Value(bool value = false) => _value = value;
       public void Update(bool newValue) {
           if (newValue == _value)
               return;
   
           _value = newValue;
           ValueChanged?.Invoke();
   
       }
   }
   

   И затем вы используете его следующим образом:

   Value _myValue = new();
   void OnEnable() => _myValue.ValueChanged += YourFunction;
   void OnDisable() => _myValue.ValueChanged -= YourFunction;
   void YourFunction() { }
   
   void Update() {
       bool newValue = your calculations;
       _myValue.Update(newValue);
   }
   

   Этот код уже кричит, что часть your calculations должна перейти в Update класса Value, поскольку теперь ясно, что именно этот класс принимает решения. Я не буду здесь углубляться в рефакторинг, но извлечение классов является распространенным инструментом. Также не забывайте переименовывать классы в соответствии с их назначением.

   События также допускают параметры:

   public class Value {
       bool _value;
       public event Action<bool> ValueChanged;
       public Value(bool value = false) => _value = value;
       public void Update(bool newValue) {
           if (newValue == _value)
               return;
   
           _value = newValue;
           ValueChanged?.Invoke(_value);
       }
   }
   

   Value _myValue = new();
   void OnEnable() => _myValue.ValueChanged += YourFunction;
   void OnDisable() => _myValue.ValueChanged -= YourFunction;
   void YourFunction(bool newValue) { }
   
   void Update() {
       bool newValue = your calculations;
       _myValue.Update(newValue);
   }
   

   События C# также работают с MonoBehaviour:

   public class Foo : MonoBehaviour {
       public event Action HasHappened;
   }
   

   public class Bar : MonoBehaviour {
       [SerializeField] Foo _foo;
   
       void OnEnable() => _foo.HasHappened += OnHappened;
       void OnDisable() => _foo.HasHappened -= OnHappened;
   
       void OnHappened() { }
   }
   

   Таким образом, вы можете сделать класс Value классом MonoBehaviour вместо того, чтобы отправлять все параметры в его Update. Или вы можете использовать события для общения между вашими Enemy и Player классами. Распространенной реализацией является то, что один класс напрямую вызывает методы другого и подписывается на его события, чтобы получать от него ответ.

   Кроме того, события C# не доступны инспектору. Для этого вы можете использовать Unity Events

5. Наконец, существуют более продвинутые инструменты, такие как сигналы (часто входящие в состав фреймворков внедрения зависимостей, например Zenject ) или реактивные расширения, например. UniRx или R3. Эти инструменты реализуют разные подходы к общению между классами.

Пока вы работаете в рамках одного класса, используйте подход, основанный на поле или свойстве. Как только задействовано несколько классов, начните изучать события и другие инструменты.