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 AddCard(GameObject card)
{
Debug.Log("Add card to hand canvas:" + card);
if (card != null)
{
GameObject panel = Instantiate(HandPanel, Table);
CardPanel cardPanel = panel.GetComponent <CardPanel> ();
Panels.Add(panel);
card.transform.localRotation = Quaternion.identity;
card.transform.SetParent(panel.transform, false);
card.GetComponent <SmothTransform> ().StopAll();
cardPanel.AddCard(card);
card.GetComponent <CardInteraction>().SetCardOrder(50);
card.GetComponent <CardInteraction> ().CardPanelComp = cardPanel;
card.GetComponent <SmothTransform> ().SmoothScaleTo(new Vector3(CardInHandScale, CardInHandScale, CardInHandScale), 15);
}
}
private void HandleMessage(GameMessage message)
{
if (message is PlayerActionMessage)
{
PlayerActionMessage actionMessage = (PlayerActionMessage)message;
CardPanel relevantCardPanel = actionMessage.Player == _game.PlayerOne ? pYourHand : pOpponentsHand;
switch (actionMessage.PlayerActionValue)
{
case PlayerActionMessage.PlayerAction.DrawDiscard:
relevantCardPanel.AddCard(actionMessage.Card);
pStacks.DiscardCount--;
pStacks.VisibleDiscard = _game.GetVisibleDiscard();
pActions.AllowDraw = false;
pActions.AllowTake = false;
pActions.AllowDiscard = true;
break;
case PlayerActionMessage.PlayerAction.DrawStock:
pStacks.StockCount--;
relevantCardPanel.AddCard(actionMessage.Card);
pActions.AllowDraw = false;
pActions.AllowTake = false;
pActions.AllowDiscard = true;
break;
case PlayerActionMessage.PlayerAction.SetDiscard:
pStacks.DiscardCount++;
pStacks.VisibleDiscard = actionMessage.Card;
relevantCardPanel.RemoveCard(actionMessage.Card);
pActions.AllowDraw = false;
pActions.AllowTake = false;
pActions.AllowDiscard = false;
break;
case PlayerActionMessage.PlayerAction.Knock:
// TODO: handle Knock message
break;
default:
break;
}
}
else if (message is GameStatusMessage)
{
GameStatusMessage statusMessage = (GameStatusMessage)message;
switch (statusMessage.GameStatusChangeValue)
{
case GameStatusMessage.GameStatusChange.GameInitialised:
// TODO: assumes PlayerOne is always the human player
pYourHand.Clear();
InitialisePlayerCardPanel(pYourHand);
foreach (Card c in _game.PlayerOne.GetCards())
{
pYourHand.AddCard(c);
}
pOpponentsHand.Clear();
InitialiseOpponentCardPanel(pOpponentsHand);
foreach (Card c in _game.PlayerTwo.GetCards())
{
pOpponentsHand.AddCard(c);
}
InitialiseStacks(_game.GetStockCount(), _game.GetVisibleDiscard());
InitialisePlayerActions();
break;
case GameStatusMessage.GameStatusChange.StartTurn:
if (statusMessage.Player == _game.PlayerOne)
{
pActions.AllowTake = true;
pActions.AllowDraw = true;
}
else
{
pActions.AllowTake = false;
pActions.AllowDraw = false;
}
break;
default:
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);
}
