Service Locator в играх: мощный паттерн или антипаттерн – выбор

public interface IAudioService
{
void PlaySound(string soundId, float volume);
void StopAllSounds();
}

public class UnityAudioService : MonoBehaviour, IAudioService
{
public void PlaySound(string soundId, float volume)
{
// Имплементация проигрывания звука в Unity
}

public void StopAllSounds()
{
// Остановка всех звуков
}
}

public static class ServiceLocator
{
private static readonly Dictionary<Type, object> _services = new Dictionary<Type, object>();

public static void RegisterService<T>(T service)
{
_services[typeof(T)] = service;
}

public static T GetService<T>() where T : class
{
if (_services.TryGetValue(typeof(T), out var service))
{
return (T)service;
}

Debug.LogError($"Service {typeof(T).Name} not registered!");
return null;
}
}

// В классе, ответственном за инициализацию игры
void Start()
{
var audioService = FindObjectOfType<UnityAudioService>();
ServiceLocator.RegisterService<IAudioService>(audioService);
}

// В игровой логике
void OnEnemyDefeated()
{
ServiceLocator.GetService<IAudioService>().PlaySound("victory", 1.0f);
}

// Определение интерфейса
UINTERFACE(BlueprintType)
class MYGAME_API UInventoryServiceInterface : public UInterface
{
GENERATED_BODY()
};

class MYGAME_API IInventoryServiceInterface
{
GENERATED_BODY()
public:
virtual void AddItem(const FName& ItemId, int Count) = 0;
virtual int GetItemCount(const FName& ItemId) const = 0;
};

// Реализация сервиса
UCLASS()
class MYGAME_API UInventoryService : public UGameInstanceSubsystem, 
public IInventoryServiceInterface
{
GENERATED_BODY()
private:
TMap<FName, int> Items;

public:
virtual void AddItem(const FName& ItemId, int Count) override;
virtual int GetItemCount(const FName& ItemId) const override;
};

// Service Locator
UCLASS()
class MYGAME_API UGameServiceLocator : public UGameInstanceSubsystem
{
GENERATED_BODY()
private:
UPROPERTY()
TMap<UClass*, UObject*> RegisteredServices;

public:
template<class T>
void RegisterService(T* Service)
{
RegisteredServices.Add(T::StaticClass(), Service);
}

template<class T>
T* GetService()
{
UObject** FoundService = RegisteredServices.Find(T::StaticClass());
return FoundService ? Cast<T>(*FoundService) : nullptr;
}
};

public class ServiceLocator : MonoBehaviour
{
private static ServiceLocator _instance;
private Dictionary<Type, object> _services = new Dictionary<Type, object>();
private Dictionary<Type, List<Action>> _awaitingCallbacks = new Dictionary<Type, List<Action>>();

public static void Initialize()
{
if (_instance != null) return;

var go = new GameObject("[ServiceLocator]");
_instance = go.AddComponent<ServiceLocator>();
DontDestroyOnLoad(go);
}

public static void RegisterService<T>(T service) where T : class
{
if (_instance == null)
{
Debug.LogError("ServiceLocator not initialized!");
return;
}

var type = typeof(T);
_instance._services[type] = service;

// Уведомляем ожидающие колбеки
if (_instance._awaitingCallbacks.TryGetValue(type, out var callbacks))
{
foreach (var callback in callbacks)
{
callback.Invoke();
}
_instance._awaitingCallbacks.Remove(type);
}
}

public static T GetService<T>() where T : class
{
if (_instance == null)
{
Debug.LogError("ServiceLocator not initialized!");
return null;
}

var type = typeof(T);
if (_instance._services.TryGetValue(type, out var service))
{
return (T)service;
}

return null;
}

// Асинхронное получение сервиса с колбеком
public static void GetServiceAsync<T>(Action<T> callback) where T : class
{
var service = GetService<T>();
if (service != null)
{
callback(service);
return;
}

var type = typeof(T);
if (!_instance._awaitingCallbacks.TryGetValue(type, out var callbacks))
{
callbacks = new List<Action>();
_instance._awaitingCallbacks[type] = callbacks;
}

callbacks.Add(() => callback(GetService<T>()));
}

// Проверка наличия сервиса
public static bool HasService<T>() where T : class
{
if (_instance == null) return false;
return _instance._services.ContainsKey(typeof(T));
}

// Замена существующего сервиса
public static void ReplaceService<T>(T newService) where T : class
{
if (_instance == null)
{
RegisterService(newService);
return;
}

_instance._services[typeof(T)] = newService;
}

// Очистка при смене сцены или выгрузке
private void OnDestroy()
{
_services.Clear();
_awaitingCallbacks.Clear();
_instance = null;
}
}

public class GameBootstrapper : MonoBehaviour
{
private void Start()
{
// Инициализация локатора
ServiceLocator.Initialize();

// Уровень 1: Базовые сервисы
InitializeCoreSystems();

// Уровень 2: Зависимые сервисы
InitializeGameSystems();

// Уровень 3: Пользовательские интерфейсы и представления
InitializeUIComponents();

// Запуск игры
StartGame();
}

private void InitializeCoreSystems()
{
// Инициализация базовых сервисов без зависимостей
var configService = new ConfigurationService();
ServiceLocator.RegisterService<IConfigurationService>(configService);

var assetService = new AssetLoaderService();
ServiceLocator.RegisterService<IAssetLoaderService>(assetService);
}

private void InitializeGameSystems()
{
// Инициализация игровых систем, которые зависят от базовых сервисов
var audioService = new AudioService(ServiceLocator.GetService<IConfigurationService>());
ServiceLocator.RegisterService<IAudioService>(audioService);

var saveSystem = new SaveSystem(ServiceLocator.GetService<IAssetLoaderService>());
ServiceLocator.RegisterService<ISaveSystem>(saveSystem);
}

private void InitializeUIComponents()
{
// Компоненты UI, которые зависят от игровых систем
var uiManager = new UIManager(
ServiceLocator.GetService<IAudioService>(),
ServiceLocator.GetService<ISaveSystem>()
);
ServiceLocator.RegisterService<IUIManager>(uiManager);
}

private void StartGame()
{
// Запуск игрового процесса
SceneManager.LoadScene("MainMenu");
}
}

public class AudioManager : MonoBehaviour
{
public static AudioManager Instance { get; private set; }

private void Awake()
{
if (Instance != null && Instance != this)
{
Destroy(gameObject);
return;
}

Instance = this;
DontDestroyOnLoad(gameObject);
}

public void PlaySound(string soundId)
{
// Реализация
}
}

// Использование
void OnEnemyDefeated()
{
AudioManager.Instance.PlaySound("victory");
}

public class Player : MonoBehaviour
{
private IAudioService _audioService;
private IInputService _inputService;

// Зависимости передаются извне
public void Initialize(IAudioService audioService, IInputService inputService)
{
_audioService = audioService;
_inputService = inputService;
}

private void OnVictory()
{
_audioService.PlaySound("victory");
}
}

// Инициализация с помощью DI-контейнера
public class GameStarter : MonoBehaviour
{
[SerializeField] private Player _playerPrefab;

private void Start()
{
var container = new DIContainer();
container.Register<IAudioService>(new UnityAudioService());
container.Register<IInputService>(new UnityInputService());

var player = Instantiate(_playerPrefab);
player.Initialize(
container.Resolve<IAudioService>(),
container.Resolve<IInputService>()
);
}
}

public class Player : MonoBehaviour
{
private IAudioService _audioService;

private void Start()
{
_audioService = ServiceLocator.GetService<IAudioService>();
}

private void OnVictory()
{
_audioService.PlaySound("victory");
}
}

// Плохо: повторные обращения к локатору
void Update()
{
if (ServiceLocator.GetService<IInputService>().IsKeyPressed("Jump"))
{
ServiceLocator.GetService<IAudioService>().PlaySound("jump");
}
}

// Хорошо: кеширование ссылок
private IInputService _inputService;
private IAudioService _audioService;

void Start()
{
_inputService = ServiceLocator.GetService<IInputService>();
_audioService = ServiceLocator.GetService<IAudioService>();
}

void Update()
{
if (_inputService.IsKeyPressed("Jump"))
{
_audioService.PlaySound("jump");
}
}

public static class CoreServices
{
private static Dictionary<Type, object> _services = new Dictionary<Type, object>();
// Методы RegisterService, GetService и т.д.
}

public static class GameplayServices
{
private static Dictionary<Type, object> _services = new Dictionary<Type, object>();
// Методы RegisterService, GetService и т.д.
}

public static class UIServices
{
private static Dictionary<Type, object> _services = new Dictionary<Type, object>();
// Методы RegisterService, GetService и т.д.
}

public static class ServiceLocator
{
private static Dictionary<Type, Func<object>> _serviceFactories = new Dictionary<Type, Func<object>>();
private static Dictionary<Type, object> _initializedServices = new Dictionary<Type, object>();

public static void RegisterServiceFactory<T>(Func<T> factory) where T : class
{
_serviceFactories[typeof(T)] = () => factory();
}

public static T GetService<T>() where T : class
{
var type = typeof(T);

// Если сервис уже инициализирован, возвращаем его
if (_initializedServices.TryGetValue(type, out var initializedService))
{
return (T)initializedService;
}

// Если есть фабрика, создаём сервис и сохраняем
if (_serviceFactories.TryGetValue(type, out var factory))
{
var service = (T)factory();
_initializedServices[type] = service;
return service;
}

Debug.LogError($"Service {type.Name} not registered!");
return null;
}
}

// Использование
void InitializeServices()
{
ServiceLocator.RegisterServiceFactory<IAudioService>(() => new UnityAudioService());
ServiceLocator.RegisterServiceFactory<INetworkService>(() => 
{
// Сложная инициализация, выполняется только при первом обращении
var service = new NetworkService();
service.Initialize();
service.Connect("game.example.com");
return service;
});
}

public class ServiceDescriptor
{
public Type ServiceType { get; }
public Func<object> Factory { get; }
public List<Type> Dependencies { get; } = new List<Type>();

public ServiceDescriptor(Type serviceType, Func<object> factory)
{
ServiceType = serviceType;
Factory = factory;
}

public ServiceDescriptor DependsOn<T>()
{
Dependencies.Add(typeof(T));
return this;
}
}

public class AdvancedServiceLocator
{
private Dictionary<Type, ServiceDescriptor> _descriptors = new Dictionary<Type, ServiceDescriptor>();
private Dictionary<Type, object> _instances = new Dictionary<Type, object>();

public ServiceDescriptor Register<T>(Func<object> factory) where T : class
{
var descriptor = new ServiceDescriptor(typeof(T), factory);
_descriptors[typeof(T)] = descriptor;
return descriptor;
}

public T GetService<T>() where T : class
{
return (T)GetService(typeof(T));
}

private object GetService(Type serviceType)
{
// Если сервис уже создан, возвращаем его
if (_instances.TryGetValue(serviceType, out var instance))
{
return instance;
}

// Если нет дескриптора, ошибка
if (!_descriptors.TryGetValue(serviceType, out var descriptor))
{
throw new Exception($"Service {serviceType.Name} not registered");
}

// Инициализируем зависимости
foreach (var dependencyType in descriptor.Dependencies)
{
GetService(dependencyType);
}

// Создаем сервис
var service = descriptor.Factory();
_instances[serviceType] = service;
return service;
}
}

// Использование
var locator = new AdvancedServiceLocator();

locator.Register<IConfigService>(() => new ConfigService())
.DependsOn<ILogService>();

locator.Register<ILogService>(() => new LogService());

locator.Register<IGameplayService>(() => new GameplayService())
.DependsOn<IConfigService>()
.DependsOn<IAudioService>();

locator.Register<IAudioService>(() => new AudioService());

// При запросе GameplayService автоматически инициализируются все зависимости
var gameplayService = locator.GetService<IGameplayService>();

public static class ServiceLocator
{
// ... предыдущий код ...

// Журнал обращений к сервисам
private static Dictionary<Type, int> _accessCount = new Dictionary<Type, int>();

public static T GetService<T>() where T : class
{
var type = typeof(T);

// Увеличиваем счетчик обращений
if (!_accessCount.ContainsKey(type))
{
_accessCount[type] = 0;
}
_accessCount[type]++;

// ... логика получения сервиса ...
}

// Метод для отладки
public static void PrintServiceStatistics()
{
foreach (var entry in _accessCount)
{
Debug.Log($"Service {entry.Key.Name}: accessed {entry.Value} times");
}
}
}