public RibbonData(string name, int amount, CardData cardData, CardSlotUI pCardSlotUI)
{
this.name = name;
this.amount = amount;
this.cardData = cardData;
this.pCardSlotUI = pCardSlotUI;
}
public void ModifyDeck(Deck userDeck)
{
deckBuilderCreationUI.SetActiveStatusPanel();
deckBuilderCreationManager.ModifyDeck(userDeck);
deckBuilderUserDeckUI.ClearUserDeckDisplay();
btnSave.onClick.RemoveAllListeners();
btnSave.onClick.AddListener(Modify);
nameInputFiled.text = userDeck.name;
gameMenuManager.LoadVisualDeckBuilder();
Dictionary <CardData, CardDisplaySlot> cardSlotUIDisplay;
cardSlotUIDisplay = cardCollectionVisualManager.GetCardDisplaySlotDictionary();
for (int i = 0; i < userDeck.userDeck.Count; i++)
{
var item = userDeck.userDeck.ElementAt(i);
for (int j = 0; j < cardSlotUIDisplay.Count; j++)
{
var itnDis = cardSlotUIDisplay.ElementAt(j);
if (item.Key.ID == itnDis.Key.ID)
{
CardSlotUI cSlot = cardSlotUIDisplay[itnDis.Key].cardSlotUI;
CardSlot slot = cSlot.cardSlot;
slot.AddDeckAmount(item.Value.Amount);
//cSlot.ChangeSlotData();
RibbonData ribbonData = new RibbonData(item.Key.CardName, item.Value.Amount, item.Key, cSlot);
ribbonManager.AddRibbon(ribbonData, deckBuilderCreationManager);
break;
}
}
}
cardCollectionSearchManager.ClearAllFiltters();
}
private void CreteSlotForCollection(CardData cardData, bool isBuilding, bool isAvailable)
{
// CARD DATA // MAX AMOUNT PER DECK // USERS COLLECTION AMOUNT
int maxPerDeck = cardData.AmountPerDeck;
int userCollAmount = gameMenuManager.GetUserCollectionAmountByCardID("CardID" + cardData.ID);
int cardsInDeck = 0;
CardSlotUI cardSlotUI = cardCollectionSlotCreator.CreateCardSlotUI(userCollAmount, cardsInDeck, maxPerDeck);
CardDisplay cardDisplay;
if (isBuilding == true)
{
cardDisplay = cardCollectionCardDisplayCreator.CreateCardDisplayForDeckBuilder(cardData, cardSlotUI, deckBuilderManager.deckBuilderCreationManager, cardScrollRectParent);
}
else
{
cardDisplay = cardCollectionCardDisplayCreator.CreateCardDisplayForCollection(cardData, cardSlotUI);
}
if (isAvailable == false)
{
SetCardToNotAvailable(cardSlotUI);
cardSlotUI.SetActive(false);
}
CardDisplaySlot cardDisplaySlot = new CardDisplaySlot(cardSlotUI, cardDisplay);
cardSlotUIDisplay.Add(cardData, cardDisplaySlot);
}
/// <summary>
/// Replaces a card from the list of unused cards with a card from the deck.
/// Sends the request to the server.
/// </summary>
private async Task <bool> ReplaceCardAsync(Card removedCard, Card usedCard)
{
// Perform card swap on server
CardOperationResponse canReplace = await DeckBuildingManager.SwapAsync(removedCard, usedCard);
if (canReplace.response == false)
{
Debug.LogWarning("Couldn't swap cards: " + canReplace.message);
return(false);
}
// Get indices of supplied cards
int usedIndex = _deck.unusedCards.IndexOf(usedCard);
int removedIndex = _deck.usedCards.IndexOf(removedCard);
// Replace cards
_deck.usedCards.RemoveAt(removedIndex);
_deck.unusedCards.RemoveAt(usedIndex);
_deck.usedCards.Insert(removedIndex, usedCard);
_deck.unusedCards.Insert(usedIndex, removedCard);
// Store changes locally
usedCard.isUsed = true;
removedCard.isUsed = false;
// Update UI
RefreshUsedCards(_deck.usedCards);
RefreshUnusedCards(_deck.unusedCards);
// Change selected card's background color
CardSlotUI slot = _deckCardsDisplays.Find(x => x.Card == usedCard);
return(true);
}
public CardDisplay CreateCardDisplayForCollection(CardData cardData, CardSlotUI cardSlotUI)
{
CardDisplay cardDisplay = CreateSimpleDisplay(cardData, cardSlotUI);
CardVisualCollectionUINEW dbUI = cardDisplay.gameObject.AddComponent <CardVisualCollectionUINEW>();
dbUI.SetSlot(cardSlotUI);
return(cardDisplay);
}
public CardSlotUI CreateCardSlotUI(int libraryAmount, int deckAmount, int totalAmountPerDeck)
{
CardSlot cardSlot = new CardSlot(libraryAmount, deckAmount, totalAmountPerDeck);
GameObject cardSlotUIPrefab = GameObject.Instantiate(cardSlotPrefab, cardLibraryTransform);
CardSlotUI cardSlotUI = cardSlotUIPrefab.GetComponent <CardSlotUI>();
cardSlotUI.InitializeCardSlot(cardSlot);
return(cardSlotUI);
}
public CardDisplay CreateSimpleDisplay(CardData cardData, CardSlotUI cardSlotUI)
{
GameObject cardPrf = GameObject.Instantiate(cardPrefab, cardSlotUI.GetCardSlotTransform().GetChild(0));
CardDisplay cardDisplay = cardPrf.GetComponent <CardDisplay>();
cardDisplay.SetDisplay(cardData);
cardSlotUI.SetCardDisplay(cardDisplay);
return(cardDisplay);
}
public CardDisplay CreateCardDisplayForDeckBuilder(CardData cardData, CardSlotUI cardSlotUI, DeckBuilderCreationManager deckBuilderCreationManager, ScrollRect cardScrollRectParent)
{
CardDisplay cardDisplay = CreateSimpleDisplay(cardData, cardSlotUI);
DeckBuilderCardOnlyClickUINEW dbUI = cardDisplay.gameObject.AddComponent <DeckBuilderCardOnlyClickUINEW>();
dbUI.SetEvent(deckBuilderCreationManager.OnTryToAddCardToDeck, cardData, cardSlotUI);
dbUI.SetScrollRect(cardScrollRectParent);
return(cardDisplay);
}
/// <summary>
/// Changes color of selected slot background.
/// </summary>
/// <param name="slot"></param>
private void ChangeSelection(CardSlotUI slot)
{
if (_selectedSlot != null)
{
_selectedSlot.Unselect();
}
_selectedSlot = slot;
if (_selectedSlot != null)
{
_selectedSlot.Select();
}
}
/// <summary>
/// Upgrades a card to the next level and removes the second.
/// </summary>
private async void OnMerge(Card upgraded, Card removed)
{
// Perform card upgrade on server
CardOperationResponse canMerge = await DeckBuildingManager.MergeAsync(upgraded, removed);
if (canMerge.response == false)
{
Debug.LogWarning("Couldn't merge cards: " + canMerge.message);
return;
}
_deck.unusedCards.Remove(removed);
// Create a new card based on the upgraded card
Card card = new Card();
card.cardType = upgraded.cardType;
card.level = upgraded.level + 1;
card.isUsed = upgraded.isUsed;
// Replace the upgraded card with newly created copy
if (upgraded.isUsed == true)
{
int index = _deck.usedCards.IndexOf(upgraded);
_deck.usedCards.RemoveAt(index);
_deck.usedCards.Insert(index, card);
}
else
{
_deck.unusedCards.Remove(upgraded);
_deck.unusedCards.Add(card);
}
// Update UI
await UpdateFundsCounterAsync();
RefreshUsedCards(_deck.usedCards);
RefreshUnusedCards(_deck.unusedCards);
CardSlotUI slot = null;
if (card.isUsed == true)
{
slot = _deckCardsDisplays.Find(x => x.Card.IsCopy(card));
}
else
{
slot = _ownedCardsDisplays.Find(x => x.Card.IsCopy(card));
}
OnCardSelected(slot);
}
/// <summary>
/// Updates the cards displayed by each <see cref="CardSlotUI"/> in user's deck.
/// </summary>
private void RefreshUsedCards(List <Card> deckCards)
{
for (int i = _deckSize - 1; i >= 0; --i)
{
CardSlotUI cardDisplay = _deckCardsDisplays[i];
if (i > _deckSize - deckCards.Count - 1)
{
cardDisplay.SetCard(deckCards[_deckSize - i - 1]);
}
else
{
cardDisplay.SetCard(null);
}
}
}
/// <summary>
/// A card has been selected by the user.
/// Shows the <see cref="_cardInfoSidePanel"/> displaying selected card's info.
/// </summary>
private async void OnCardSelected(CardSlotUI slot)
{
if (slot == null)
{
// Cannot unselect card
return;
}
else
{
ChangeSelection(slot);
if (slot.Card != null && slot.Card.isUsed == true)
{
// Selected card from deck
if (_usedCard != null)
{
// Card replacement has been already started
// Replacing _usedCard with selected card
bool good = await ReplaceCardAsync(slot.Card, _usedCard);
if (good == true)
{
EndReplaceCard();
OnCardSelected(slot);
}
}
else
{
_cardInfoSidePanel.SetUsedCard(slot.Card, OnMerge, _funds >= 50);
}
}
else
{
// Selected card from unused card list
_cardInfoSidePanel.SetUnusedCard(slot.Card, BegniReplaceCard, OnMerge);
if (_usedCard != null)
{
// Card replacement has been started but user didn't select any card
// from deck. Terminating card replacement
EndReplaceCard();
}
}
}
}
/// <summary>
/// Fills the deck panel and unused cards panel with cards retrieved from the server.
/// </summary>
private async void Init()
{
NakamaSessionManager.Instance.OnConnectionSuccess -= Init;
_deck = await _deckStorage.LoadDataAsync("deck");
if (_deck == null)
{
_deck = GenerateDefaultDeck(_defaultDeck);
await _deckStorage.StoreDataAsync(_deck);
}
_cardInfoSidePanel.SetDeck(_deck);
// Create a number of CardMenuUI equal to _deckSize and initialize them with user cards.
for (int i = _deckSize - 1; i >= 0; i--)
{
CardSlotUI cardDisplay = Instantiate(_slotPrefab, _deckPanel.transform, false);
cardDisplay.Init(OnCardSelected);
_deckCardsDisplays.Add(cardDisplay);
if (i < _deck.usedCards.Count)
{
cardDisplay.SetCard(_deck.usedCards[i]);
}
else
{
cardDisplay.SetCard(null);
}
}
// Update the unused cards panel UI
RefreshUnusedCards(_deck.unusedCards);
// Refresh gems counter
await UpdateFundsCounterAsync();
// Select first slot if no card is selected
if (_selectedSlot == null)
{
OnCardSelected(_deckCardsDisplays[0]);
}
}
public void SetSlot(CardSlotUI cardSlotUI)
{
this.cardSlotUI = cardSlotUI;
}
private void SetCardToNotAvailable(CardSlotUI cardSlotUI)
{
cardSlotUI.SetIsAvailable(false);
}
private void SetCardToAvailable(CardSlotUI cardSlotUI)
{
cardSlotUI.SetIsAvailable(true);
}
public CardDisplaySlot(CardSlotUI cardSlotUI, CardDisplay cardDisplay)
{
this.cardSlotUI = cardSlotUI;
this.cardDisplay = cardDisplay;
}
public void SetEvent(Action <CardData, CardSlotUI> OnCardClick, CardData pCardData, CardSlotUI cardSlotUI)
{
this.OnCardClick = OnCardClick;
this.pCardData = pCardData;
SetSlot(cardSlotUI);
}
public void OnTryToAddCardToDeck(CardData cardData, CardSlotUI pCardSlotUI)
{
if (isEditing == false)
{
return;
}
if (auxDeck == null)
{
if (debugOn)
{
Debug.Log("NO AUX DECK");
}
return;
}
// REHABILITAR CUANDO SE ACTUALIZEN BIEN LOS DATOS DE LA BD ONLINE
//if (cardData.IsAvailable == false)
//{
// if (debugOn) Debug.Log("CARD NOT AVAILABLE YET");
// return;
//}
if (pCardSlotUI.cardSlot.userCollectionAmount <= 0)
{
if (debugOn)
{
Debug.Log("NO QUEDAN DE ESAS CARDS EN LA COLECCION");
}
return;
}
if (auxDeck.totalCards >= CardPropertiesDatabase.maxAmountOfCardsPerDeck)
{
if (debugOn)
{
Debug.Log("SE SUPERO EL LIMITE DE CARDS POR MAZO");
}
return;
}
if (auxDeck.GerCardAmountByRarity(cardData.CardRarity) >= CardPropertiesDatabase.GetAmountPerCardPerLevelPerDeck()[cardData.CardRarity])
{
if (debugOn)
{
Debug.Log("SE SUPERO EL LIMITE DE CARDS POR TIPO DE RAREZA");
}
return;
}
if (auxDeck.GetCardAmount(cardData) >= cardData.AmountPerDeck)
{
if (debugOn)
{
Debug.Log("SE SUPERO EL LIMITE DE CARDS POR TIPO ESE TIPO DE CARD");
}
return;
}
auxDeck.AddCard(cardData);
pCardSlotUI.cardSlot.AddDeckAmount();
RibbonData ribbonData = new RibbonData(cardData.CardName, pCardSlotUI.cardSlot.deckAmount, cardData, pCardSlotUI);
ribbonManager.AddRibbon(ribbonData, this);
if (debugOn)
{
Debug.Log("CARD ADDED " + cardData.CardName);
}
OnDeckChange?.Invoke(auxDeck);
isDirty = true;
}