private void LoadDeckObjects()
        {
            FillHordeDecks();

            _newHordeDeckObject.transform.SetAsLastSibling();
            _newHordeDeckObject.SetActive(true);

            HordeDeckObject deck =
                _hordeDecks.Find(x => x.SelfDeck.Id == _dataManager.CachedUserLocalData.LastSelectedDeckId);

            if (deck != null)
            {
                HordeDeckSelectedHandler(deck);
            }

            if (_hordeDecks.Count > 0)
            {
                HordeDeckObject foundDeck = _hordeDecks.FirstOrDefault(o => o.SelfDeck.Id == _selectedDeckId);
                if (foundDeck == null)
                {
                    _selectedDeckId = (int)_hordeDecks[0].SelfDeck.Id;
                }
            }
            else
            {
                _selectedDeckId = -1;
            }

            CenterTheSelectedDeck();
            BattleButtonUpdate();
        }
        private void HordeDeckSelectedHandler(HordeDeckObject deck)
        {
            if (_hordeSelection.gameObject.activeSelf)
            {
                HordeDeckObject horde = _hordeDecks.FirstOrDefault(o => o.SelfDeck.Id == _selectedDeckId);
                horde.Deselect();
            }

            deck.Select();

            _firstSkill.sprite = _loadObjectsManager.GetObjectByPath <Sprite>("Images/HeroesIcons/heroability_" +
                                                                              deck.SelfHero.Element.ToUpper() + "_" +
                                                                              deck.SelfHero.Skills[deck.SelfHero.PrimarySkill].Skill.ToLower());
            _secondSkill.sprite = _loadObjectsManager.GetObjectByPath <Sprite>("Images/HeroesIcons/heroability_" +
                                                                               deck.SelfHero.Element.ToUpper() + "_" +
                                                                               deck.SelfHero.Skills[deck.SelfHero.SecondarySkill].Skill.ToLower());

            _hordeSelection.transform.SetParent(deck.SelectionContainer, false);
            _hordeSelection.gameObject.SetActive(true);

            _selectedDeckId = (int)deck.SelfDeck.Id;
            _dataManager.CachedUserLocalData.LastSelectedDeckId = _selectedDeckId;

            _dataManager.SaveCache(Enumerators.CacheDataType.USER_LOCAL_DATA);
            deck.SelectionContainer.parent.SetAsLastSibling();

            BattleButtonUpdate();
        }
        private void SkillButtonOnDoubleClickHandler(int skillIndex)
        {
            _soundManager.PlaySound(Enumerators.SoundType.CLICK, Constants.SfxSoundVolume, false, false, true);
            HordeDeckObject deck = _hordeDecks.FirstOrDefault(o => o.SelfDeck.Id == _selectedDeckId);

            if (deck != null)
            {
                _uiManager.DrawPopup <OverlordAbilitySelectionPopup>(deck.SelfHero);
            }
        }
        private void SkillButtonOnSingleClickHandler(int skillIndex)
        {
            _soundManager.PlaySound(Enumerators.SoundType.CLICK, Constants.SfxSoundVolume, false, false, true);
            HordeDeckObject deck = _hordeDecks.FirstOrDefault(o => o.SelfDeck.Id == _selectedDeckId);

            if (deck != null)
            {
                HeroSkill skill = skillIndex == 0 ?
                                  deck.SelfHero.Skills[deck.SelfHero.PrimarySkill] :
                                  deck.SelfHero.Skills[deck.SelfHero.SecondarySkill];

                _uiManager.DrawPopup <OverlordAbilityTooltipPopup>(skill);
            }
        }
        private void EditButtonOnClickHandler()
        {
            if (ShowConnectionLostPopupIfNeeded())
            {
                return;
            }

            if (_selectedDeckId != -1)
            {
                _soundManager.PlaySound(Enumerators.SoundType.CLICK, Constants.SfxSoundVolume, false, false, true);

                _uiManager.GetPage <DeckEditingPage>().CurrentDeckId = _selectedDeckId;
                HordeDeckObject deck = _hordeDecks.FirstOrDefault(o => o.SelfDeck.Id == _selectedDeckId);
                _uiManager.GetPage <DeckEditingPage>().CurrentHeroId = deck.SelfHero.HeroId;
                _appStateManager.ChangeAppState(Enumerators.AppState.DECK_EDITING);
            }
        }
        private void ConfirmDeleteDeckReceivedHandler(bool status)
        {
            _uiManager.GetPopup <QuestionPopup>().ConfirmationReceived -= ConfirmDeleteDeckReceivedHandler;

            if (!status)
            {
                return;
            }

            HordeDeckObject deckToDelete = _hordeDecks.FirstOrDefault(o => o.SelfDeck.Id == _selectedDeckId);

            if (deckToDelete != null)
            {
                DeckDeletingHandler(deckToDelete);
            }

            BattleButtonUpdate();
        }
        private void DeleteButtonOnClickHandler()
        {
            if (ShowConnectionLostPopupIfNeeded())
            {
                return;
            }

            HordeDeckObject deck = _hordeDecks.FirstOrDefault(o => o.SelfDeck.Id == _selectedDeckId);

            if (deck != null)
            {
                _soundManager.PlaySound(Enumerators.SoundType.CLICK, Constants.SfxSoundVolume, false, false, true);

                _uiManager.GetPopup <QuestionPopup>().ConfirmationReceived += ConfirmDeleteDeckReceivedHandler;

                _uiManager.DrawPopup <QuestionPopup>("Do you really want to delete " + deck.SelfDeck.Name + "?");
            }
        }
        private void FillHordeDecks()
        {
            ResetHordeDecks();
            _hordeDecks = new List <HordeDeckObject>();

            for (int i = 0; i < _dataManager.CachedDecksData.Decks.Count; i++)
            {
                HordeDeckObject hordeDeck =
                    new HordeDeckObject(
                        _containerOfDecks,
                        _dataManager.CachedDecksData.Decks[i],
                        _dataManager.CachedHeroesData.HeroesParsed.Find(x =>
                                                                        x.HeroId == _dataManager.CachedDecksData.Decks[i].HeroId),
                        i);
                hordeDeck.HordeDeckSelected += HordeDeckSelectedHandler;

                _hordeDecks.Add(hordeDeck);
            }

            _newHordeDeckObject.transform.localPosition = Vector3.right * HordeItemSpace * _hordeDecks.Count;
        }
        private async void DeckDeletingHandler(HordeDeckObject deck)
        {
            // HACK for offline mode in online mode, local data should only be saved after
            // backend operation has succeeded
            _dataManager.CachedDecksData.Decks.Remove(deck.SelfDeck);
            _dataManager.CachedUserLocalData.LastSelectedDeckId = -1;
            _dataManager.CachedDecksLastModificationTimestamp   = Utilites.GetCurrentUnixTimestampMillis();
            await _dataManager.SaveCache(Enumerators.CacheDataType.DECKS_DATA);

            await _dataManager.SaveCache(Enumerators.CacheDataType.USER_LOCAL_DATA);

            try
            {
                await _backendFacade.DeleteDeck(
                    _backendDataControlMediator.UserDataModel.UserId,
                    deck.SelfDeck.Id,
                    _dataManager.CachedDecksLastModificationTimestamp
                    );

                Debug.Log($" ====== Delete Deck {deck.SelfDeck.Id} Successfully ==== ");
            }
            catch (Exception e)
            {
                // HACK for offline mode
#pragma warning disable 162
                if (false)
                {
                    Debug.Log("Result === " + e);
                    OpenAlertDialog($"Not able to Delete Deck {deck.SelfDeck.Id}: " + e.Message);
                    return;
                }
#pragma warning restore 162
            }

            LoadDeckObjects();
        }