Engine/GameService.cs - solid - expens1ve/project_war

Engine/GameService.cs
137 строк5 KB
Vadim
add solid vibes
02 июн 2026, 01:09
02 июн 2026, 01:09573f19e
using System;
using System.Collections.Generic;
using project_war.Engine.Formations;
using project_war.Engine.Interfaces;
using project_war.Models;
using project_war.Models.Interfaces;
using project_war.Persistence.Interfaces;
using project_war.Models.Observers;

namespace project_war.Engine
{
    public class GameService : IGameService
    {
        private readonly IArmyFactory _armyFactory;
        private readonly IGameSaveManager _saveManager;
        private readonly IGameEngine _engine;
        private readonly IConfigurationManager _config;

        public GameService(IArmyFactory armyFactory, IGameSaveManager saveManager, IGameEngine engine, IConfigurationManager config)
        {
            _armyFactory = armyFactory ?? throw new ArgumentNullException(nameof(armyFactory));
            _saveManager = saveManager ?? throw new ArgumentNullException(nameof(saveManager));
            _engine = engine ?? throw new ArgumentNullException(nameof(engine));
            _config = config ?? throw new ArgumentNullException(nameof(config));
        }

        public IArmy CreateRandomArmy(int budget, string name)
        {
            var baseArmy = _armyFactory.CreateRandomArmy(budget);
            var renamedArmy = new Army(name);
            foreach (var unit in baseArmy.Units)
            {
                renamedArmy.AddUnit(unit);
            }
            return renamedArmy;
        }

        public IArmy CreateManualArmy(int budget, string name, Dictionary<Type, int> config)
        {
            var baseArmy = _armyFactory.CreateManualArmy(config, budget);
            var namedArmy = new Army(name);
            foreach (var unit in baseArmy.Units)
            {
                namedArmy.AddUnit(unit);
            }
            return namedArmy;
        }

        public (IArmy army1, IArmy army2, int roundNumber, string formationType) LoadGame(string path)
        {
            return _saveManager.LoadGameState(path);
        }

        public void SaveGame(IArmy army1, IArmy army2, int round, string formationType, string path)
        {
            _saveManager.SaveGameState(army1, army2, round, formationType, path);
        }

        public IBattlefield StartBattle(IArmy army1, IArmy army2, string? formationType = null)
        {
            _engine.StartGame(army1, army2);

            var battlefield = _engine.GetBattlefield();
            if (battlefield == null)
            {
                throw new InvalidOperationException("Поле боя не инициализировано. Убедитесь, что StartGame отработал корректно.");
            }

            if (_config.IsDamageLoggingEnabled)
            {
                // Логгер урона подписывается на события самого поля боя и держит ссылки на армии
                _ = new DamageLoggerObserver(army1, army2, battlefield);
            }

            if (_config.IsDeathBeepEnabled)
            {
                // Наблюдатель звука смерти тоже работает от глобального события Battlefield
                _ = new DeathSoundObserver(battlefield);
            }


            if (battlefield is Battlefield concreteBattlefield)
            {
                concreteBattlefield.SetFormation(CreateFormation(formationType));
            }

            return battlefield;
        }

        private static IBattleFormation CreateFormation(string? formationType)
        {
            if (string.IsNullOrWhiteSpace(formationType))
            {
                return new BridgeFormation();
            }

            return formationType.Trim() switch
            {
                nameof(BridgeFormation) or "Узкий мост" => new BridgeFormation(),
                nameof(WideBridgeFormation) or "Широкий мост (3 бойца)" => new WideBridgeFormation(),
                nameof(WallFormation) or "Стенка на стенку" => new WallFormation(),
                _ => new BridgeFormation()
            };
        }

        public string GetStateSnapshot(IArmy army1, IArmy army2, int roundNumber, string formationType)
        {
            return _saveManager.SerializeGameState(army1, army2, roundNumber, formationType);
        }

        public void ApplySnapshotToArmies(string snapshot, IArmy targetArmy1, IArmy targetArmy2, Action<int, string>? updateRoundAndFormation = null)
        {
            var (loadedArmy1, loadedArmy2, round, formation) = _saveManager.DeserializeGameState(snapshot);

            RestoreArmyContent(targetArmy1, loadedArmy1);
            RestoreArmyContent(targetArmy2, loadedArmy2);

            updateRoundAndFormation?.Invoke(round, formation);
        }

        private static void RestoreArmyContent(IArmy target, IArmy snapshot)
        {
            // Очищаем текущую армию, не теряя ссылку на сам объект
            var toRemove = new List<IUnit>(target.Units);
            foreach (var unit in toRemove)
            {
                target.RemoveUnit(unit);
            }

            // Добавляем новые копии юнитов из снимка
            foreach (var unit in snapshot.Units)
            {
                target.AddUnit(unit);
            }
        }
    }
}