PPAGameUI/ViewModels/SetupViewModel.cs - gameUI-clean - romashov.z/PPAGame

PPAGameUI/ViewModels/SetupViewModel.cs
250 строк9 KB
Artemiy Ivanov
PPAGame + PPAGameUI Avalonia UI
02 июн 2026, 13:42
02 июн 2026, 13:42c122c02
using System;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Runtime.CompilerServices;
using System.Windows.Input;
using ArmyBattleGame;

namespace PPAGameUI.ViewModels;

public enum ObserverMode { Full, DeathsOnly, None }

public class SetupViewModel : INotifyPropertyChanged
{
    private readonly MainWindowViewModel _main;
    private readonly GameSaveService _saveService = new();
    private readonly Random _rnd = new();

    // --- Имена армий ---
    private string _army1Name = "Армия 1";
    public string Army1Name
    {
        get => _army1Name;
        set { _army1Name = value; OnPropertyChanged(); }
    }

    private string _army2Name = "Армия 2";
    public string Army2Name
    {
        get => _army2Name;
        set { _army2Name = value; OnPropertyChanged(); }
    }

    // --- Бюджет ---
    private double _budget = 500;
    public double Budget
    {
        get => _budget;
        set
        {
            _budget = value;
            OnPropertyChanged();
            OnPropertyChanged(nameof(Army1CostText));
            OnPropertyChanged(nameof(Army2CostText));
            OnPropertyChanged(nameof(Army1RemainingText));
            OnPropertyChanged(nameof(Army2RemainingText));
        }
    }

    // --- Режим наблюдателей ---
    private ObserverMode _observerMode = ObserverMode.Full;

    public bool IsObsFull
    {
        get => _observerMode == ObserverMode.Full;
        set { if (value) _observerMode = ObserverMode.Full; }
    }
    public bool IsObsDeaths
    {
        get => _observerMode == ObserverMode.DeathsOnly;
        set { if (value) _observerMode = ObserverMode.DeathsOnly; }
    }
    public bool IsObsNone
    {
        get => _observerMode == ObserverMode.None;
        set { if (value) _observerMode = ObserverMode.None; }
    }

    // --- Юниты армий ---
    private readonly ObservableCollection<IUnit> _army1Real = new();
    private readonly ObservableCollection<IUnit> _army2Real = new();
    public ObservableCollection<UnitViewModel> Army1Units { get; } = new();
    public ObservableCollection<UnitViewModel> Army2Units { get; } = new();

    private double _army1Cost;
    private double _army2Cost;

    public string Army1CostText     => $"Потрачено: {_army1Cost:F0} / {Budget:F0}";
    public string Army2CostText     => $"Потрачено: {_army2Cost:F0} / {Budget:F0}";
    public string Army1RemainingText => $"Остаток: {Math.Max(0, Budget - _army1Cost):F0}";
    public string Army2RemainingText => $"Остаток: {Math.Max(0, Budget - _army2Cost):F0}";

    // --- Текущая армия для добавления ---
    private int _currentArmy = 1;
    public int CurrentArmy
    {
        get => _currentArmy;
        set { _currentArmy = value; OnPropertyChanged(); OnPropertyChanged(nameof(CurrentArmyText)); }
    }
    public string CurrentArmyText => $"Добавить в: {(CurrentArmy == 1 ? Army1Name : Army2Name)}";

    // --- Ошибка ---
    private string _errorText = "";
    public string ErrorText
    {
        get => _errorText;
        set { _errorText = value; OnPropertyChanged(); }
    }

    // --- Команды ---
    public ICommand AddHeavyCommand    { get; }
    public ICommand AddLiteCommand     { get; }
    public ICommand AddArcherCommand   { get; }
    public ICommand AddHealerCommand   { get; }
    public ICommand AddWizardCommand   { get; }
    public ICommand AddGulyayCommand   { get; }
    public ICommand AutoArmy1Command   { get; }
    public ICommand AutoArmy2Command   { get; }
    public ICommand ClearArmy1Command  { get; }
    public ICommand ClearArmy2Command  { get; }
    public ICommand SwitchArmyCommand  { get; }
    public ICommand StartBattleCommand { get; }
    public ICommand BackCommand        { get; }

    public SetupViewModel(MainWindowViewModel main)
    {
        _main = main;

        AddHeavyCommand    = new RelayCommand(() => AddUnit(1));
        AddLiteCommand     = new RelayCommand(() => AddUnit(2));
        AddArcherCommand   = new RelayCommand(() => AddUnit(3));
        AddHealerCommand   = new RelayCommand(() => AddUnit(4));
        AddWizardCommand   = new RelayCommand(() => AddUnit(5));
        AddGulyayCommand   = new RelayCommand(() => AddUnit(6));
        AutoArmy1Command   = new RelayCommand(() => BuildRandom(1));
        AutoArmy2Command   = new RelayCommand(() => BuildRandom(2));
        ClearArmy1Command  = new RelayCommand(() => ClearArmy(1));
        ClearArmy2Command  = new RelayCommand(() => ClearArmy(2));
        SwitchArmyCommand  = new RelayCommand(() => CurrentArmy = CurrentArmy == 1 ? 2 : 1);
        StartBattleCommand = new RelayCommand(StartBattle);
        BackCommand        = new RelayCommand(_main.ShowMainMenu);
    }

    private void AddUnit(int type)
    {
        var realList = CurrentArmy == 1 ? _army1Real : _army2Real;
        var viewList = CurrentArmy == 1 ? Army1Units  : Army2Units;
        double spent = CurrentArmy == 1 ? _army1Cost  : _army2Cost;

        IUnit unit = type switch
        {
            1 => UnitFactory.CreateHeavy(),
            2 => UnitFactory.CreateLite(),
            3 => UnitFactory.CreateRandomArcher(_rnd),
            4 => UnitFactory.CreateRandomHealer(_rnd),
            5 => UnitFactory.CreateRandomWizard(_rnd),
            6 => UnitFactory.CreateGulyayGorod(),
            _ => UnitFactory.CreateHeavy()
        };

        if (spent + unit.Cost > Budget)
        {
            ErrorText = $"Недостаточно бюджета! (нужно {unit.Cost:F0}, остаток {Budget - spent:F0})";
            return;
        }

        ErrorText = "";
        realList.Add(unit);
        viewList.Add(new UnitViewModel(unit));

        if (CurrentArmy == 1) _army1Cost += unit.Cost;
        else                   _army2Cost += unit.Cost;

        RefreshCosts();
    }

    private void BuildRandom(int armyNum)
    {
        ClearArmy(armyNum);

        var tempArmy = new Army();
        new ArmyBuilder(Budget, _rnd).BuildRandom(tempArmy);

        var realList = armyNum == 1 ? _army1Real : _army2Real;
        var viewList = armyNum == 1 ? Army1Units  : Army2Units;
        double cost = 0;

        foreach (var unit in tempArmy.AllUnits)
        {
            realList.Add(unit);
            viewList.Add(new UnitViewModel(unit));
            cost += unit.Cost;
        }

        if (armyNum == 1) _army1Cost = cost;
        else               _army2Cost = cost;

        RefreshCosts();
        ErrorText = "";
    }

    private void ClearArmy(int armyNum)
    {
        if (armyNum == 1) { _army1Real.Clear(); Army1Units.Clear(); _army1Cost = 0; }
        else               { _army2Real.Clear(); Army2Units.Clear(); _army2Cost = 0; }
        RefreshCosts();
    }

    private void RefreshCosts()
    {
        OnPropertyChanged(nameof(Army1CostText));
        OnPropertyChanged(nameof(Army2CostText));
        OnPropertyChanged(nameof(Army1RemainingText));
        OnPropertyChanged(nameof(Army2RemainingText));
    }

    private void StartBattle()
    {
        if (_army1Real.Count == 0 || _army2Real.Count == 0)
        {
            ErrorText = "Каждая армия должна иметь хотя бы одного юнита!";
            return;
        }

        ErrorText = "";

        GameSettings.EnableDamageLog  = _observerMode == ObserverMode.Full;
        GameSettings.EnableDeathSound = _observerMode == ObserverMode.Full;

        var army1 = new Army();
        var army2 = new Army();
        foreach (var u in _army1Real) { u.ArmyId = 1; army1.AddUnit(u); }
        foreach (var u in _army2Real) { u.ArmyId = 2; army2.AddUnit(u); }

        var observers = new BattleObservers();
        observers.Attach(army1);
        observers.Attach(army2);

        var logMode = _observerMode switch
        {
            ObserverMode.Full       => LogMode.Full,
            ObserverMode.DeathsOnly => LogMode.DeathsOnly,
            _                       => LogMode.None
        };

        var logger = new GuiBattleLogger(logMode);
        var battle = new BattleField(army1, army2, logger);

        string a1Name = string.IsNullOrWhiteSpace(Army1Name) ? "Армия 1" : Army1Name;
        string a2Name = string.IsNullOrWhiteSpace(Army2Name) ? "Армия 2" : Army2Name;

        var battleVm = new BattleViewModel(battle, _saveService, Budget, observers, a1Name, a2Name);
        battleVm.ConnectLogger(logger);
        battleVm.ExitRequested += _main.ShowMainMenu;
        _main.ShowBattle(battleVm);
    }

    public event PropertyChangedEventHandler? PropertyChanged;
    private void OnPropertyChanged([CallerMemberName] string? name = null)
        => PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(name));
}