initial commit

Assets/Scripts/GameManager.cs

@@ -0,0 +1,361 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using Cysharp.Threading.Tasks;
+using TMPro;
+using UnityEngine;
+
+public class GameManager : MonoBehaviour
+{
+    public static GameManager Instance { get; private set; }
+
+    [Header("Containers")]
+    public CardContainer deckContainer;
+
+    public CardContainer handContainer;
+    public CardContainer boardContainer;
+    public CardContainer discardContainer;
+
+    [Header("Prefabs & UI")]
+    public CardView cardPrefab;
+    public TMP_Text statusText;
+    public TMP_Text scoreText;
+
+    [Header("Rules")]
+    public int maxHandSize = 4;
+
+    private int _playerScore;
+    private int _enemyScore;
+    private bool _isBusy;
+    private CancellationToken _destroyToken;
+
+    private void Awake()
+    {
+        Instance = this;
+        _destroyToken = this.GetCancellationTokenOnDestroy();
+    }
+
+    private void Start()
+    {
+        StartGameAsync().Forget();
+    }
+
+    private async UniTaskVoid StartGameAsync()
+    {
+        _isBusy = true;
+        UpdateScoreUI();
+        SetStatus("Подготовка колоды...");
+
+        CreateAndShuffleDeck();
+        await UniTask.Delay(400, cancellationToken: _destroyToken);
+
+        SetStatus("Раздаём карты...");
+        for (var i = 0; i < 3; i++)
+        {
+            await DrawTopCardToHandAsync();
+        }
+
+        SetStatus("Ваш ход: сыграйте карту на поле или сбросьте ненужную");
+        _isBusy = false;
+    }
+
+    private void CreateAndShuffleDeck()
+    {
+        var models = new List<CardModel>();
+
+        for (var copy = 0; copy < 2; copy++)
+        {
+            foreach (CardSuit suit in Enum.GetValues(typeof(CardSuit)))
+            {
+                foreach (CardRank rank in Enum.GetValues(typeof(CardRank)))
+                {
+                    models.Add(new CardModel(suit, rank));
+                }
+            }
+        }
+
+        for (var i = models.Count - 1; i > 0; i--)
+        {
+            var rnd = UnityEngine.Random.Range(0, i + 1);
+            (models[i], models[rnd]) = (models[rnd], models[i]);
+        }
+
+        foreach (var model in models)
+        {
+            var card = Instantiate(cardPrefab, deckContainer.cardHolder);
+            card.Initialize(model, faceUp: false);
+            deckContainer.AddCardInstant(card);
+        }
+    }
+
+    public bool CanStartDrag(CardView card)
+    {
+        if (_isBusy || card.CurrentContainer == null) return false;
+
+        return card.CurrentContainer.type switch
+        {
+            ContainerType.Deck => deckContainer.Cards.Count > 0 && deckContainer.Cards.Contains(card),
+            ContainerType.Hand => true,
+            ContainerType.Board => true,
+            ContainerType.Discard => discardContainer.Cards.Count > 0 && discardContainer.Cards.Contains(card),
+            _ => false
+        };
+    }
+
+    public async UniTask HandleCardDropAsync(CardView card, CardContainer origin, CardContainer target, int returnIndex)
+    {
+        _isBusy = true;
+
+        if (target == null || target == origin)
+        {
+            await origin.AddCardAnimatedAsync(card, returnIndex, _destroyToken);
+            _isBusy = false;
+            return;
+        }
+
+        switch (origin.type)
+        {
+            case ContainerType.Deck when target.type == ContainerType.Hand:
+            {
+                if (handContainer.Cards.Count < maxHandSize)
+                {
+                    await handContainer.AddCardAnimatedAsync(card, -1, _destroyToken);
+                    SetStatus($"Взята карта: {FormatCardName(card.Model)}");
+                }
+                else
+                {
+                    SetStatus($"В руке нет места (максимум {maxHandSize} карты)");
+                    await origin.AddCardAnimatedAsync(card, returnIndex, _destroyToken);
+                }
+
+                break;
+            }
+            case ContainerType.Hand when target.type == ContainerType.Board:
+                await boardContainer.AddCardAnimatedAsync(card, -1, _destroyToken);
+                await ResolveBattleOnBoardAsync(card);
+                break;
+            case ContainerType.Hand when target.type == ContainerType.Discard:
+                await discardContainer.AddCardAnimatedAsync(card, -1, _destroyToken);
+                SetStatus($"Сброшен {FormatCardName(card.Model)}. Берём замену...");
+                await UniTask.Delay(250, cancellationToken: _destroyToken);
+                await DrawTopCardToHandAsync();
+                SetStatus("Ваш ход: выберите карту для атаки");
+                break;
+            case ContainerType.Discard when target.type == ContainerType.Deck:
+                await deckContainer.AddCardAnimatedAsync(card, -1, _destroyToken);
+                await RecycleDiscardToDeckAsync();
+                SetStatus("Сброшенные карты вернулись в колоду!");
+                break;
+            case ContainerType.Board when target.type == ContainerType.Discard:
+                await discardContainer.AddCardAnimatedAsync(card, -1, _destroyToken);
+                SetStatus("Карта отправлена в сброс");
+                break;
+            default:
+                SetStatus("Сюда карту положить нельзя");
+                await origin.AddCardAnimatedAsync(card, returnIndex, _destroyToken);
+                break;
+        }
+
+        _isBusy = false;
+    }
+
+    private async UniTask ResolveBattleOnBoardAsync(CardView playerCard)
+    {
+        SetStatus($"Вы сыграли: {FormatCardName(playerCard.Model)}. Ход противника...");
+        await UniTask.Delay(400, cancellationToken: _destroyToken);
+
+        if (deckContainer.Cards.Count == 0)
+        {
+            await RecycleDiscardToDeckAsync();
+        }
+
+        if (deckContainer.Cards.Count == 0)
+        {
+            SetStatus("В колоде закончились карты. Ничья в раунде!");
+            boardContainer.RemoveCardListReference(playerCard);
+            await discardContainer.AddCardAnimatedAsync(playerCard, -1, _destroyToken);
+            return;
+        }
+
+        var enemyCard = deckContainer.Cards[^1];
+        deckContainer.RemoveCardListReference(enemyCard);
+        await boardContainer.AddCardAnimatedAsync(enemyCard, -1, _destroyToken);
+
+        await UniTask.Delay(650, cancellationToken: _destroyToken);
+
+        var result = CompareCards(playerCard.Model, enemyCard.Model);
+        switch (result)
+        {
+            case > 0:
+                _playerScore++;
+                SoundManager.Instance?.PlayWin();
+                SetStatus($"Победа! Ваш {FormatCardName(playerCard.Model)} побеждает {FormatCardNameGenitive(enemyCard.Model)}!");
+                break;
+            case < 0:
+                _enemyScore++;
+                SoundManager.Instance?.PlayLose();
+                SetStatus($"Поражение: {FormatCardName(enemyCard.Model)} соперника оказался сильнее.");
+                break;
+            default:
+                SetStatus("Боевая ничья! Силы стихий равны.");
+                break;
+        }
+
+        UpdateScoreUI();
+        await UniTask.Delay(1100, cancellationToken: _destroyToken);
+
+        boardContainer.RemoveCardListReference(playerCard);
+        boardContainer.RemoveCardListReference(enemyCard);
+
+        await UniTask.WhenAll(
+            discardContainer.AddCardAnimatedAsync(playerCard, -1, _destroyToken),
+            discardContainer.AddCardAnimatedAsync(enemyCard, -1, _destroyToken)
+        );
+
+        if (handContainer.Cards.Count == 0)
+        {
+            if (deckContainer.Cards.Count == 0)
+                await RecycleDiscardToDeckAsync();
+
+            await DrawTopCardToHandAsync();
+        }
+
+        SetStatus("Ваш ход: выберите карту для атаки");
+    }
+
+    private int CompareCards(CardModel p, CardModel e)
+    {
+        if (p.rank != e.rank)
+            return p.rank > e.rank ? 1 : -1;
+
+        if (p.suit == e.suit)
+            return 0;
+
+        var playerSuitAdvantage =
+            (p.suit == CardSuit.Fire && e.suit == CardSuit.Earth) ||
+            (p.suit == CardSuit.Earth && e.suit == CardSuit.Air) ||
+            (p.suit == CardSuit.Air && e.suit == CardSuit.Water) ||
+            (p.suit == CardSuit.Water && e.suit == CardSuit.Fire);
+
+        return playerSuitAdvantage ? 1 : -1;
+    }
+
+    private async UniTask DrawTopCardToHandAsync()
+    {
+        if (deckContainer.Cards.Count == 0 || handContainer.Cards.Count >= maxHandSize) return;
+
+        var topCard = deckContainer.Cards[^1];
+        deckContainer.RemoveCardListReference(topCard);
+        await handContainer.AddCardAnimatedAsync(topCard, -1, _destroyToken);
+    }
+
+    private async UniTask RecycleDiscardToDeckAsync()
+    {
+        if (discardContainer.Cards.Count == 0) return;
+
+        SetStatus("Перетасовываем сброс обратно в колоду...");
+        var cardsToRecycle = new List<CardView>(discardContainer.Cards);
+        discardContainer.Cards.Clear();
+
+        foreach (var c in cardsToRecycle)
+        {
+            await deckContainer.AddCardAnimatedAsync(c, -1, _destroyToken);
+        }
+    }
+
+    public async UniTaskVoid DrawCardByClickAsync()
+    {
+        if (_isBusy) return;
+        if (handContainer.Cards.Count >= maxHandSize)
+        {
+            SetStatus($"В руке уже максимум карт ({maxHandSize})");
+            return;
+        }
+
+        _isBusy = true;
+        await DrawTopCardToHandAsync();
+        _isBusy = false;
+    }
+
+    public async UniTaskVoid PlayCardFromHandByClickAsync(CardView card)
+    {
+        if (_isBusy || card == null || card.CurrentContainer != handContainer) return;
+
+        _isBusy = true;
+        handContainer.RemoveCardListReference(card);
+        await boardContainer.AddCardAnimatedAsync(card, -1, _destroyToken);
+        await ResolveBattleOnBoardAsync(card);
+        _isBusy = false;
+    }
+
+    public async UniTaskVoid RecycleDiscardByClickAsync()
+    {
+        if (_isBusy) return;
+        if (discardContainer.Cards.Count == 0)
+        {
+            SetStatus("Стопка сброса пуста");
+            return;
+        }
+
+        _isBusy = true;
+        await RecycleDiscardToDeckAsync();
+        SetStatus("Колода пополнена из сброса!");
+        _isBusy = false;
+    }
+
+    private void UpdateScoreUI()
+    {
+        if (scoreText != null)
+            scoreText.text = $"Игрок: {_playerScore}  |  Противник: {_enemyScore}";
+    }
+
+    private void SetStatus(string message)
+    {
+        if (statusText != null)
+            statusText.text = message;
+    }
+
+    private static string FormatCardName(CardModel card)
+    {
+        var rank = card.rank switch
+        {
+            CardRank.Servant => "Слуга",
+            CardRank.Knight => "Рыцарь",
+            CardRank.Lord => "Владыка",
+            _ => "Воин"
+        };
+
+        var suit = card.suit switch
+        {
+            CardSuit.Fire => "Огня",
+            CardSuit.Earth => "Земли",
+            CardSuit.Air => "Воздуха",
+            CardSuit.Water => "Воды",
+            _ => ""
+        };
+
+        return $"{rank} {suit}";
+    }
+
+    private static string FormatCardNameGenitive(CardModel card)
+    {
+        var rank = card.rank switch
+        {
+            CardRank.Servant => "Слугу",
+            CardRank.Knight => "Рыцаря",
+            CardRank.Lord => "Владыку",
+            _ => "Воина"
+        };
+
+        var suit = card.suit switch
+        {
+            CardSuit.Fire => "Огня",
+            CardSuit.Earth => "Земли",
+            CardSuit.Air => "Воздуха",
+            CardSuit.Water => "Воды",
+            _ => ""
+        };
+
+        return $"{rank} {suit}";
+    }
+}