private void SetRemovableStates(UnitRelativeOwner owner)
    {
        var canRemovePlayerCharacters = matchupData[owner].Count > 1;

        foreach (var character in matchupData[owner])
        {
            character.SetRemoveButtonActive(canRemovePlayerCharacters);
        }
    }
    public void Setup(int slotID, UnitRelativeOwner owner, UnityAction <UnitRelativeOwner, int> onCharacterRemoved)
    {
        this.SlotID             = slotID;
        this.onCharacterRemoved = onCharacterRemoved;
        this.UnitOwner          = owner;
        this.UnitClass          = default;

        this.UnitIdentifier = new UnitIdentifier(owner == UnitRelativeOwner.Self ? 0 : 1, slotID, default);

        UpdateDescription();

        if (owner == UnitRelativeOwner.Opponent)
        {
            characterSlotPresenter.OverrideColorScheme();
        }
    }
    private void OnAnyCharacterRemoved(UnitRelativeOwner owner, int slotId)
    {
        var slotToRemove = matchupData[owner].Find((slot) => slot.SlotID == slotId);

        if (slotToRemove != null)
        {
            matchupData[owner].Remove(slotToRemove);
            Destroy(slotToRemove.gameObject);

            SetRemovableStates(owner);
            SetCharacterAddableState(owner);
        }
        else
        {
            Debug.LogError($"[MatchPreparationMaster] Trying to remove unassigned slot id {slotId}");
        }
    }
    public void SetAddCharacterButton(UnitRelativeOwner owner, bool value)
    {
        if (owner == UnitRelativeOwner.Self)
        {
            addPlayerCharacterButton.gameObject.SetActive(value);
        }

        else if (owner == UnitRelativeOwner.Opponent)
        {
            addOpponentCharacterButton.gameObject.SetActive(value);
        }

        else
        {
            Debug.LogError($"[MatchPreparationPresenter] Unexpected unit owner {owner}");
        }
    }
 private void SetCharacterAddableState(UnitRelativeOwner owner)
 {
     matchPreparationPresenter.SetAddCharacterButton(owner, matchupData[owner].Count < MAX_CHARACTERS_PER_TEAM);
 }
 private void AddCharacter(UnitRelativeOwner owner, bool initialCharacter = false)
 {
     matchupData[owner].Add(matchPreparationPresenter.CreateSlot(uniqueId++, characterSlotMaster, owner, OnAnyCharacterRemoved));
     SetRemovableStates(owner);
     SetCharacterAddableState(owner);
 }
    public CharacterSlotMaster CreateSlot(int slotID, CharacterSlotMaster characterSlot, UnitRelativeOwner owner, UnityAction <UnitRelativeOwner, int> onSlotRemovedCallback)
    {
        switch (owner)
        {
        case UnitRelativeOwner.Self:
        {
            var slot = Instantiate(characterSlot, playerSlotRoot);
            slot.Setup(slotID, owner, onSlotRemovedCallback);
            return(slot);
        }

        case UnitRelativeOwner.Opponent:
        {
            var slot = Instantiate(characterSlot, opponentSlotRoot);
            slot.Setup(slotID, owner, onSlotRemovedCallback);
            return(slot);
        }

        case UnitRelativeOwner.None:
        case UnitRelativeOwner.Ally:
            Debug.LogError($"[MatchPreparationPresenter] Trying to create character slot for unsupported owner {owner}");
            break;
        }

        return(null);
    }