mixedcards/Assets/Battle/BattlePlayerControls.cs

using System.Collections;
using System.Collections.Generic;
using System.Linq;
using UnityEngine;
using UnityEngine.UI;

public class BattlePlayerControls : MonoBehaviour
{
    // TODO: Draw enemy permanents

    public BattleController battleController;
    public GameObject uiCanvas;
    public GameObject cardPrefab;

    public delegate void CardUsedAction(HeroCard card);
    public event CardUsedAction OnCardUsed;
    public delegate void TurnPassedAction();
    public event TurnPassedAction OnTurnPassed;

    private BattleDeck<HeroCard> heroDeck;
    private BattleDeck<MonsterCard> monsterDeck;
    private PlayArea playArea;

    private HeroHandControls heroHandControls;
    private Dictionary<BaseCard, GameObject> cardsInPlayUIs;

    public void Init(
            BattleDeck<HeroCard> heroDeck, BattleDeck<MonsterCard> monsterDeck, PlayArea playArea) {
        this.heroDeck = heroDeck;
        this.monsterDeck = monsterDeck;
        this.playArea = playArea;

        this.heroHandControls = new HeroHandControls(this, this.uiCanvas, this.cardPrefab);
        this.heroHandControls.OnCardClicked += OnCardClicked;
        this.cardsInPlayUIs = new Dictionary<BaseCard, GameObject>();
    }

    // Start is called before the first frame update
    void Start()
    {
        NotifyPlayAreaChanged();
        this.playArea.OnPlayAreaChanged += NotifyPlayAreaChanged;
    }

    // Update is called once per frame
    void Update()
    {
        
    }

    private void SetMonsterHand(List<MonsterCard> hand) {
        // TODO
    }

    private void OnCardClicked(HeroCard card) {
        if (this.singleTargeting == null) {
            if (this.battleController.CanUseHeroCard(card)) {
                OnCardUsed(card);
            }
        }
    }

    private SingleTargeting singleTargeting;

    public IEnumerator ChooseTarget(SingleTargeting targeting) {
        this.singleTargeting = targeting;
        yield return this.singleTargeting.ChooseTarget();
        this.singleTargeting = null;
    }

    public void NotifyParticipantSpriteClicked(BattleParticipant participant) {
        if (this.singleTargeting != null) {
            this.singleTargeting.NotifyParticipantSpriteClicked(participant);
        }
    }

    public void PassTurnButtonClicked() {
        if (this.singleTargeting == null) {
            OnTurnPassed();
        }
    }

    public bool CouldTarget(BattleParticipant participant) {
        return this.singleTargeting != null && this.singleTargeting.CanTarget(participant);
    }

    public void NotifyHeroHandPileChanged() {
        this.heroHandControls.SetHeroHand(this.heroDeck.GetHandPile().ToList());
    }

    public void NotifyMonsterHandPileChanged() {
        SetMonsterHand(this.monsterDeck.GetHandPile().ToList());
    }

    private void NotifyPlayAreaChanged() {
        DestroyCardsThatLeftPlayArea();
        CreateCardsThatEnteredPlayArea();
        RepositionCardsInPlayArea();
    }

    private void DestroyCardsThatLeftPlayArea() {
        List<BaseCard> cardsToRemove = new List<BaseCard>();
        foreach (KeyValuePair<BaseCard, GameObject> pair in this.cardsInPlayUIs) {
            if (!this.playArea.GetHeroPermanents().Contains(pair.Key)) {
                Destroy(pair.Value);
                cardsToRemove.Add(pair.Key);
            }
        }

        foreach (BaseCard cardToRemove in cardsToRemove) {
            this.cardsInPlayUIs.Remove(cardToRemove);
        }
    }

    private void CreateCardsThatEnteredPlayArea() {
        foreach (BaseCard card in this.playArea.GetHeroPermanents()) {
            if (!this.cardsInPlayUIs.ContainsKey(card)) {
                GameObject cardUI = Instantiate(this.cardPrefab, this.uiCanvas.transform);
                // Leave position to be set by RepositionCardsInPlayArea();
                cardUI.GetComponent<CardUI>().Init(card);
                this.cardsInPlayUIs.Add(card, cardUI);
            }
        }
    }

    private void RepositionCardsInPlayArea() {
        List<BaseCard> permanentList = this.playArea.GetHeroPermanents();
        for (int i = 0; i < permanentList.Count; i++) {
            BaseCard card = permanentList[i];
            GameObject cardUI = this.cardsInPlayUIs[card];
            cardUI.transform.position = CalculatePlayAreaCardPosition(i, permanentList.Count);
        }
    }
    
    private Vector3 CalculatePlayAreaCardPosition(int index, int count) {
        const int SPACING = 8;
        const int DELTA = BattleCardPrefabConstants.CARD_HEIGHT + SPACING;
        const int PADDING = 8;
        
        return new Vector3(PADDING + BattleCardPrefabConstants.CARD_WIDTH / 2,
                Screen.height - PADDING - DELTA * index - BattleCardPrefabConstants.CARD_HEIGHT / 2,
                0);
    }
}