private void SortList()
{
List <string> cardNames = new List <string> ();
framesToWait = true;
foreach (GameObject findedPanelOb in PanelsInDeckList)
{
cardDescStruct newCard = new cardDescStruct();
CardPanel findedPanel = findedPanelOb.GetComponent <CardPanel> ();
newCard.CardName = findedPanel.PanelCardName;
if (findedPanel.Card != null)
{
newCard.Card = findedPanel.Card;
}
newCard.CardsNumber = findedPanel.CardsNumber;
PanelsInDeckCards.Add(newCard);
cardNames.Add(findedPanel.PanelCardName);
Destroy(findedPanel.PrevCard);
findedPanel.DestroyPanelOnly();
}
PanelsInDeckList.Clear();
cardNames = CardsBaseComponent.SortCardsList(cardNames);
foreach (string cardName in cardNames)
{
GameObject panel = Instantiate(CardPanel);
CardPanel panelComp = panel.GetComponent <CardPanel> ();
panel.transform.SetParent(CardsInDeckTable, false);
panelComp.PanelInDeck = true;
foreach (cardDescStruct cardStOb in PanelsInDeckCards)
{
if (string.Compare(cardStOb.CardName, cardName) == 0)
{
panelComp.KeepCardPosition = false;
panelComp.CardPosReached = false;
if (cardStOb.Card != null)
{
panelComp.AddCard(cardStOb.Card);
}
panelComp.PanelCardName = cardStOb.CardName;
panelComp.CardsNumber = cardStOb.CardsNumber;
panelComp.RefreshCardsNumber();
break;
}
}
PanelsInDeckList.Add(panel);
}
PanelsInDeckCards.Clear();
}
public void RemoveCard(string cardName)
{
Debug.Log("Remove card from deck:" + cardName);
DeckTableControllerComponent.RemoveCardFromDeck(CardsBaseComponent.GetIdByName(cardName).ToString());
CardsInDeckNames.Remove(cardName);
foreach (GameObject findedPanelOb in PanelsInDeckList)
{
if (findedPanelOb != null)
{
CardPanel findedPanel = findedPanelOb.GetComponent <CardPanel> ();
if (findedPanel != null)
{
if (findedPanel.PanelCardName == cardName)
{
findedPanel.CardsNumber--;
findedPanel.RefreshCardsNumber();
if (findedPanel.CardsNumber < 1)
{
findedPanel.DestroyPanel();
PanelsInDeckList.Remove(findedPanelOb);
break;
}
}
}
else
{
CardViewPanel panel = findedPanelOb.GetComponent <CardViewPanel> ();
if (panel != null)
{
if (panel.PanelPawn.GetComponent <Pawn> ().Name == cardName)
{
PanelsInDeckList.Remove(findedPanelOb);
//Destroy (findedPanelOb);
break;
}
}
}
}
}
}
private IEnumerator LoadCardPoolTask(Hero hero)
{
PoolUnload = false;
while (PoolLoading)
{
yield return(new WaitForSeconds(0.01f));
}
PoolLoading = true;
List <CardsBase.CardDescriptionClass> cardsList;
Color panelColor = Color.white;
if (hero != null)
{
cardsList = CardsBaseComponent.GetCardsList(hero.CardsPool);
panelColor = hero.HeroColor;
CurrentHero = hero;
Debug.Log(" Load Card pool for: " + hero.Name + " pool:" + hero.CardsPool);
}
else
{
cardsList = CardsBaseComponent.GetCardsList(CardsBase.SelectedHeroCards.Uniwersal);
Debug.Log(" Load Card uniwersal pool");
}
foreach (CardsBase.CardDescriptionClass cardToSpawn in cardsList)
{
if (PoolUnload)
{
break;
}
bool FilterOut = false;
//public List<string> RarityFilterList = new List<string>() {"Wszystkie", "Srebrne", "Złote", "Diamentowe"};
//public List<string> RolesFilterList = new List<string>() {"Wszystkie role", "Ofensywne", "Defensywne", "Wspierające"};
if ((CurrentRarityFilter == 1) && (cardToSpawn.Rarity != CardInteraction.CardRarityEnum.common))
{
FilterOut = true;
}
else if ((CurrentRarityFilter == 2) && (cardToSpawn.Rarity != CardInteraction.CardRarityEnum.gold))
{
FilterOut = true;
}
else if ((CurrentRarityFilter == 3) && (cardToSpawn.Rarity != CardInteraction.CardRarityEnum.diamond))
{
FilterOut = true;
}
if ((CurrentRoleFilter == 1) && (cardToSpawn.Role != CardInteraction.CardRoleEnum.offence))
{
FilterOut = true;
}
else if ((CurrentRoleFilter == 2) && (cardToSpawn.Role != CardInteraction.CardRoleEnum.defence))
{
FilterOut = true;
}
else if ((CurrentRoleFilter == 3) && (cardToSpawn.Role != CardInteraction.CardRoleEnum.support))
{
FilterOut = true;
}
if (!FilterOut)
{
GameObject card = CardsBaseComponent.SpawnCard(cardToSpawn, true);
if (card)
{
CardInteraction CardInter = card.GetComponent <CardInteraction> ();
GameObject panel = Instantiate(CardPanel);
CardPanel panelComp = panel.GetComponent <CardPanel> ();
if (!cardToSpawn.CardUnlocked)
{
if (ShowAllToggle.isOn)
{
card.GetComponent <SpriteRenderer> ().color = new Color(1f, 1f, 1f, 0.5f);
}
else
{
FilterOut = true;
}
}
if (SetCardAsButtonChild)
{
card.transform.SetParent(panel.transform);
}
else
{
card.transform.SetParent(CardsBasePositionRoot);
}
card.transform.position = new Vector3(-10000, 0, 0); //just keep card outside of camera
card.GetComponent <CardInteraction> ().SetCardOrder(1);
if (collectionMode)
{
panel.transform.SetParent(CardsCollectionTable, false);
card.transform.localScale = InCollectionCardScale;
panelComp.BuildDeckMode = false;
}
else
{
panel.transform.SetParent(CardsBaseTable, false);
//card.transform.localScale = InTableCardScale;
card.transform.localScale = InCollectionCardScale;
panelComp.BuildDeckMode = true;
}
if (cardToSpawn.NewlyUnlocked)
{
panelComp.NewNotifyObject = Instantiate(NewCardNotifyPrefab, panel.transform);
}
panelComp.PanelInDeck = false;
panelComp.PanelButton.image.color = panelColor;
panelComp.AddCard(card);
panelComp.KeepCardPosition = true;
panelComp.CardsNumber = cardToSpawn.Quantity;
panelComp.RefreshCardsNumber();
card.transform.position = panel.transform.position;
PanelsInCardsList.Add(panel);
yield return(new WaitForSeconds(0.01f));
}
}
//Debug.Log ("set card from current pos: " + card.transform.position + " to new pos: " + panel.transform.position);
}
PoolLoading = false;
yield return(null);
}
private void AddCardToTable(string cardName, Vector3 startCardGlobalPosition, bool noAnim, List <GameObject> spawnedPawns = null)
{
GameObject card = null;
GameObject pawn = null;
if (DeckBuildV2 && spawnedPawns != null)
{
pawn = FindSpawnedCard(spawnedPawns, cardName);
}
if (pawn == null)
{
card = CardsBaseComponent.SpawnCardByName(cardName);
}
if (DeckBuildV2)
{
bool availble = true;
if (card)
{
//availble = CheckCardQuantity (cardName);
pawn = card.transform.Find("Pawn").gameObject;
pawn.transform.SetParent(CardsInDeckPositionRoot);
Destroy(card);
}
if (availble)
{
CardsInDeckNames.Add(pawn.GetComponent <Pawn>().Name);
CardsInDeckNames = CardsBaseComponent.SortCardsList(CardsInDeckNames);
GameObject panel = Instantiate(DeckPanelV2Prefab);
if (panel != null)
{
panel.transform.SetParent(DeckBuildV2Table.transform, false);
panel.transform.SetSiblingIndex(CardsInDeckNames.IndexOf(pawn.GetComponent <Pawn>().Name));
PanelsInDeckList.Add(panel);
if (pawn != null)
{
CardViewPanel panelView = panel.GetComponent <CardViewPanel> ();
pawn.GetComponent <KeepParentRenderLayer> ().KeepingActive = false;
pawn.gameObject.GetComponent <SpriteRenderer> ().sortingOrder = 55;
pawn.transform.SetParent(CardsInDeckPositionRoot);
pawn.transform.position = startCardGlobalPosition;
panelView.SetPawn(pawn, null);
panelView.TableWidth = DeckBuildV2Table.GetComponent <RectTransform> ().rect.width;
panelView.MovePawn(true);
panelView.CardsControllerComp = GetComponent <CardsBaseTableController> ();
pawn.transform.localScale = InTableCardScale;
}
}
}
else
{
DeckTableControllerComponent.RemoveCardFromDeck(cardName);
}
}
else
{
GameObject panel;
bool panelFinded = false;
CardPanel panelComp;
if (card)
{
card.transform.SetParent(CardsInDeckPositionRoot);
card.transform.localScale = InTableCardScale;
card.transform.position = startCardGlobalPosition;
card.GetComponent <CardInteraction> ().SetCardOrder(3);
foreach (GameObject findedPanelOb in PanelsInDeckList)
{
CardPanel findedPanel = findedPanelOb.GetComponent <CardPanel> ();
if (findedPanel.PanelCardName == cardName)
{
CardInteraction CardInter = card.GetComponent <CardInteraction> ();
bool availble = true;
if ((CardInter.CardRarity == CardInteraction.CardRarityEnum.common) &&
(findedPanel.CardsNumber >= 3))
{
availble = false;
}
else if ((CardInter.CardRarity == CardInteraction.CardRarityEnum.gold) &&
(findedPanel.CardsNumber >= 2))
{
availble = false;
}
else if ((CardInter.CardRarity == CardInteraction.CardRarityEnum.diamond) &&
(findedPanel.CardsNumber >= 1))
{
availble = false;
}
if (availble)
{
findedPanel.CardsNumber++;
findedPanel.RefreshCardsNumber();
panelComp = findedPanel;
//panelComp.KeepCardPosition = false;
if (noAnim)
{
Destroy(card);
}
panelComp.AddCard(card);
//panelComp.SmoothMoveCard ();
//panelComp.KeepCardPosition = true;
}
else
{
DeckTableControllerComponent.RemoveCardFromDeck(cardName);
Destroy(card);
}
panelFinded = true;
}
}
if (panelFinded == false)
{
panel = Instantiate(CardPanel);
panelComp = panel.GetComponent <CardPanel> ();
panel.transform.SetParent(CardsInDeckTable, false);
panelComp.PanelInDeck = true;
//panelComp.KeepCardPosition = false;
panelComp.PanelCardName = cardName;
panelComp.AddCard(card);
//panelComp.SmoothMoveCard ();
panelComp.RefreshCardsNumber();
//panelComp.KeepCardPosition = true;
PanelsInDeckList.Add(panel);
SortList();
}
}
}
}
