Паттерн Observer в геймдеве: создание гибкой архитектуры без связей

public interface IObserver
{
void OnNotify(object data);
}

public class Subject
{
private List<IObserver> _observers = new List<IObserver>();

public void AddObserver(IObserver observer)
{
_observers.Add(observer);
}

public void RemoveObserver(IObserver observer)
{
_observers.Remove(observer);
}

public void NotifyObservers(object data)
{
foreach (var observer in _observers)
{
observer.OnNotify(data);
}
}
}

public class HealthSystem : MonoBehaviour
{
private Subject _subject = new Subject();
private int _health = 100;

public void TakeDamage(int amount)
{
_health -= amount;
_subject.NotifyObservers(_health);
}

public void RegisterObserver(IObserver observer)
{
_subject.AddObserver(observer);
}
}

public class HealthUI : MonoBehaviour, IObserver
{
public void OnNotify(object data)
{
int health = (int)data;
// Обновление UI
}
}

public class PlayerHealth : MonoBehaviour
{
public event Action<int> OnHealthChanged;
private int _currentHealth = 100;

public void TakeDamage(int damage)
{
_currentHealth -= damage;
OnHealthChanged?.Invoke(_currentHealth);
}
}

// Использование
public class HealthBar : MonoBehaviour
{
[SerializeField] private PlayerHealth _playerHealth;

private void OnEnable()
{
_playerHealth.OnHealthChanged += UpdateHealthBar;
}

private void OnDisable()
{
_playerHealth.OnHealthChanged -= UpdateHealthBar;
}

private void UpdateHealthBar(int health)
{
// Обновление полосы здоровья
}
}

[CreateAssetMenu(fileName = "GameEvent", menuName = "Events/Game Event")]
public class GameEvent : ScriptableObject
{
private List<GameEventListener> _listeners = new List<GameEventListener>();

public void Raise()
{
for (int i = _listeners.Count – 1; i >= 0; i--)
{
_listeners[i].OnEventRaised();
}
}

public void RegisterListener(GameEventListener listener)
{
_listeners.Add(listener);
}

public void UnregisterListener(GameEventListener listener)
{
_listeners.Remove(listener);
}
}

public class GameEventListener : MonoBehaviour
{
public GameEvent Event;
public UnityEvent Response;

private void OnEnable()
{
Event.RegisterListener(this);
}

private void OnDisable()
{
Event.UnregisterListener(this);
}

public void OnEventRaised()
{
Response.Invoke();
}
}

public class ReactivePlayer : MonoBehaviour
{
private ReactiveProperty<int> _healthReactive = new ReactiveProperty<int>(100);

public IReadOnlyReactiveProperty<int> Health => _healthReactive;

public void TakeDamage(int damage)
{
_healthReactive.Value -= damage;
}
}

// Использование
public class ReactiveHealthUI : MonoBehaviour
{
[SerializeField] private ReactivePlayer _player;

private void Start()
{
_player.Health
.Where(health => health < 30)
.Subscribe(health => {
// Визуальное предупреждение о низком здоровье
})
.AddTo(this);

_player.Health
.Subscribe(UpdateHealthBar)
.AddTo(this);
}

private void UpdateHealthBar(int health)
{
// Обновление интерфейса
}
}

// Объявление делегата
DECLARE_DELEGATE_OneParam(FOnHealthChanged, float);

// В классе персонажа
class MYGAME_API AMyCharacter : public ACharacter
{
public:
// Публичный делегат для подписки
FOnHealthChanged OnHealthChanged;

private:
float Health = 100.0f;

public:
void TakeDamage(float DamageAmount)
{
Health -= DamageAmount;
// Уведомляем подписчиков
OnHealthChanged.ExecuteIfBound(Health);
}
};

// Использование в другом классе
void AHealthDisplay::BeginPlay()
{
Super::BeginPlay();

if (AMyCharacter* PlayerCharacter = Cast<AMyCharacter>(UGameplayStatics::GetPlayerCharacter(this, 0)))
{
PlayerCharacter->OnHealthChanged.BindUObject(this, &AHealthDisplay::UpdateHealthBar);
}
}

void AHealthDisplay::UpdateHealthBar(float NewHealth)
{
// Обновление интерфейса
}

// Объявление мультикаст-делегата
DECLARE_MULTICAST_DELEGATE_OneParam(FOnPlayerDamaged, float);

class MYGAME_API AGameStateManager : public AActor
{
public:
// Статический экземпляр для доступа из любой точки
static FOnPlayerDamaged OnPlayerDamaged;

// Метод для инициирования события
void ReportPlayerDamage(float DamageAmount)
{
OnPlayerDamaged.Broadcast(DamageAmount);
}
};

// Инициализация статического делегата
FOnPlayerDamaged AGameStateManager::OnPlayerDamaged;

// Подписка в другом классе
void ASoundManager::BeginPlay()
{
Super::BeginPlay();

// Подписываемся на событие урона игроку
AGameStateManager::OnPlayerDamaged.AddUObject(this, &ASoundManager::PlayDamageSound);
}

void ASoundManager::EndPlay(const EEndPlayReason::Type EndPlayReason)
{
Super::EndPlay(EndPlayReason);

// Обязательно отписываемся, чтобы избежать утечек
AGameStateManager::OnPlayerDamaged.RemoveAll(this);
}

void ASoundManager::PlayDamageSound(float DamageAmount)
{
// Логика воспроизведения звука в зависимости от урона
}

DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnEnemyKilled, AEnemy*, KilledEnemy);

class MYGAME_API AEnemyManager : public AActor
{
GENERATED_BODY()

public:
// Делегат доступный в Blueprint
UPROPERTY(BlueprintAssignable, Category = "Events")
FOnEnemyKilled OnEnemyKilled;

// Вызов события при убийстве врага
UFUNCTION(BlueprintCallable, Category = "Gameplay")
void ReportEnemyKilled(AEnemy* Enemy)
{
OnEnemyKilled.Broadcast(Enemy);
}
};

// Интерфейс для объектов, реагирующих на входы игрока
UINTERFACE(MinimalAPI, Blueprintable)
class UInputResponder : public UInterface
{
GENERATED_BODY()
};

class IInputResponder
{
GENERATED_BODY()

public:
// Методы, которые должны реализовать подписчики
UFUNCTION(BlueprintCallable, BlueprintImplementableEvent)
void OnMoveInput(const FVector2D& MovementVector);

UFUNCTION(BlueprintCallable, BlueprintImplementableEvent)
void OnActionInput(const FName& ActionName);
};

// Класс, который уведомляет подписчиков
class MYGAME_API AInputController : public APlayerController
{
GENERATED_BODY()

private:
// Массив текущих объектов, получающих уведомления
UPROPERTY()
TArray<AActor*> InputResponders;

public:
// Регистрирует объект как подписчика на события ввода
UFUNCTION(BlueprintCallable)
void RegisterInputResponder(AActor* Responder)
{
if (Responder && Responder->GetClass()->ImplementsInterface(UInputResponder::StaticClass()))
{
InputResponders.AddUnique(Responder);
}
}

// Отменяет регистрацию
UFUNCTION(BlueprintCallable)
void UnregisterInputResponder(AActor* Responder)
{
InputResponders.Remove(Responder);
}

// При получении ввода уведомляет всех подписчиков
virtual void ProcessPlayerInput(const float DeltaTime, const bool bGamePaused) override
{
Super::ProcessPlayerInput(DeltaTime, bGamePaused);

FVector2D MovementVector(InputComponent->GetAxisValue("MoveForward"), 
InputComponent->GetAxisValue("MoveRight"));

for (AActor* Responder : InputResponders)
{
IInputResponder::Execute_OnMoveInput(Responder, MovementVector);
}
}
};

public class OptimizedEventManager : MonoBehaviour
{
// Предварительное выделение памяти с оценкой максимума подписчиков
private Dictionary<string, HashSet<Action<object>>> _eventHandlers = 
new Dictionary<string, HashSet<Action<object>>>(50);

// Кэш для избежания частых выделений памяти
private List<Action<object>> _tempHandlersList = new List<Action<object>>(20);

// Буфер событий для группировки
private Queue<KeyValuePair<string, object>> _eventQueue = 
new Queue<KeyValuePair<string, object>>(100);

public void Subscribe(string eventName, Action<object> handler)
{
if (!_eventHandlers.TryGetValue(eventName, out var handlers))
{
handlers = new HashSet<Action<object>>();
_eventHandlers[eventName] = handlers;
}
handlers.Add(handler);
}

public void Unsubscribe(string eventName, Action<object> handler)
{
if (_eventHandlers.TryGetValue(eventName, out var handlers))
{
handlers.Remove(handler);
}
}

// Добавляем событие в буфер вместо немедленной отправки
public void QueueEvent(string eventName, object data)
{
_eventQueue.Enqueue(new KeyValuePair<string, object>(eventName, data));
}

// Обрабатываем буфер событий в конце кадра для группировки
private void LateUpdate()
{
ProcessEventQueue();
}

private void ProcessEventQueue()
{
int processedEvents = 0;
int maxEventsPerFrame = 50; // Ограничение числа событий на кадр

while (_eventQueue.Count > 0 && processedEvents < maxEventsPerFrame)
{
var eventData = _eventQueue.Dequeue();
TriggerEvent(eventData.Key, eventData.Value);
processedEvents++;
}
}

private void TriggerEvent(string eventName, object data)
{
if (!_eventHandlers.TryGetValue(eventName, out var handlers) || handlers.Count == 0)
return;

// Используем кэшированный список для избежания выделений памяти
_tempHandlersList.Clear();
_tempHandlersList.AddRange(handlers);

foreach (var handler in _tempHandlersList)
{
handler.Invoke(data);
}
}
}

public class SpatialEventSystem : MonoBehaviour
{
// Хранение подписчиков с их позициями
private Dictionary<IObserver, Vector3> _observerPositions = new Dictionary<IObserver, Vector3>();

// Регистрация с позицией
public void RegisterObserver(IObserver observer, Vector3 position)
{
_observerPositions[observer] = position;
}

// Обновление позиции
public void UpdateObserverPosition(IObserver observer, Vector3 newPosition)
{
if (_observerPositions.ContainsKey(observer))
_observerPositions[observer] = newPosition;
}

// Отправка события только наблюдателям в радиусе
public void TriggerLocalizedEvent(object data, Vector3 eventPosition, float radius)
{
float sqrRadius = radius * radius;

foreach (var kvp in _observerPositions)
{
if ((kvp.Value – eventPosition).sqrMagnitude <= sqrRadius)
{
kvp.Key.OnNotify(data);
}
}
}
}

public async Task NotifyObserversAsync(object data)
{
foreach (var observer in _observers)
{
// Запускаем каждое уведомление асинхронно
await Task.Run(() => observer.OnNotify(data));
}
}

// Или в версии с параллельной обработкой
public async Task NotifyObserversParallelAsync(object data)
{
var tasks = _observers.Select(observer => 
Task.Run(() => observer.OnNotify(data))).ToArray();

await Task.WhenAll(tasks);
}

// Unity
public class Player : MonoBehaviour
{
public event Action<int> OnScoreChanged;

private int _score;

public void AddScore(int points)
{
_score += points;
OnScoreChanged?.Invoke(_score);
}
}

// Unreal
UCLASS()
class MYGAME_API APlayer : public ACharacter
{
GENERATED_BODY()

public:
// Объявление делегата, доступного в Blueprint
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnScoreChangedSignature, int32, NewScore);

// Экземпляр делегата
UPROPERTY(BlueprintAssignable, Category = "Events")
FOnScoreChangedSignature OnScoreChanged;

private:
UPROPERTY(Replicated)
int32 Score;

public:
UFUNCTION(BlueprintCallable, Category = "Gameplay")
void AddScore(int32 Points)
{
Score += Points;
OnScoreChanged.Broadcast(Score);
}
};

// Unity с UnityEvent
public class InteractiveObject : MonoBehaviour
{
[SerializeField] 
private UnityEvent<int> OnValueChanged;

public void ChangeValue(int newValue)
{
OnValueChanged.Invoke(newValue);
}
}

// Unreal с Blueprint Implementable Event
UCLASS()
class MYGAME_API AInteractiveObject : public AActor
{
GENERATED_BODY()

public:
// Событие, которое можно реализовать в Blueprint
UFUNCTION(BlueprintImplementableEvent, Category = "Interaction")
void OnValueChanged(int32 NewValue);

UFUNCTION(BlueprintCallable, Category = "Interaction")
void ChangeValue(int32 NewValue)
{
OnValueChanged(NewValue);
}
};

// Unity с UniRx
// Создаем Observable объект
ReactiveProperty<int> health = new ReactiveProperty<int>(100);

// Подписываемся с фильтрацией
health.Where(h => h < 30)
.Subscribe(_ => PlayWarningSound())
.AddTo(this.gameObject);

// Комбинируем потоки событий
Observable.CombineLatest(
health, 
shield, 
(h, s) => new { Health = h, Shield = s }
)
.Subscribe(state => UpdateUI(state.Health, state.Shield))
.AddTo(this.gameObject);