Exemplo n.º 1
0
        public void RemoveCards(IList <CardView> cards)
        {
            foreach (var card in cards)
            {
                if (card == _interactingCard)
                {
                    _interactingCard = null;
                    _cardInteraction = CardInteraction.None;
                }
                UnregisterCardEvents(card);
            }
            var nonexisted = new List <CardView>(
                from c in cards
                where !_cards.Contains(c)
                select c);
            var space = MaxCardSpacing;

            MaxCardSpacing = 30;
            RearrangeCards(nonexisted);
            MaxCardSpacing = space;
            if (nonexisted.Count != cards.Count)
            {
                _cards = new List <CardView>(_cards.Except(cards));
                RearrangeCards(_cards);
            }
        }
Exemplo n.º 2
0
 private void NewTurnCallback(int idx)
 {
     if (FirstGetCost)
     {
         if (pawn != null)
         {
             if (pawn.transform.parent != null)
             {
                 CardInterComp = pawn.transform.parent.gameObject.GetComponent <CardInteraction> ();
                 if (CardInterComp != null)
                 {
                     ThisCardCost = CardInterComp.CardCost;
                 }
                 FirstGetCost = false;
             }
         }
     }
     else
     {
         if (CardInterComp != null)
         {
             CardInterComp.SetCardCost(ThisCardCost);
         }
     }
     DeathPawns = 0;
 }
Exemplo n.º 3
0
    public void SaveHand()
    {
        UpdateUserDataRequest request = new UpdateUserDataRequest();

        request.Data = new Dictionary <string, string> ();
        string cardsInHandID = "";

        foreach (GameObject cardOb in GameplayComponent.HandComp.HandCards)
        {
            CardInteraction cardInter = cardOb.GetComponent <CardInteraction> ();
            if (cardInter != null)
            {
                if (cardInter.pawnComponent != null)
                {
                    cardsInHandID += cardInter.pawnComponent.CardID.ToString() + separators[0];
                }
            }
        }
        request.Data.Add("CurrHand", cardsInHandID);
        Deck deck = GameplayComponent.myDeck.GetComponent <Deck> ();

        request.Data.Add("CurrCardsInDeck", deck.cardsInDeck.ToString());

        PlayFabClientAPI.UpdateUserData(request, HandSaved, OnPlayFabError);
    }
Exemplo n.º 4
0
 private void OnEnable()
 {
     box         = GetComponent <BoxCollider2D>();
     interaction = GetComponent <CardInteraction>();
     //sortGroup = GetComponent<SortingGroup>();
     if (!isDummy)
     {
         cardDrop.Register(SetBox);
         cardDrag.Register(ResetBox);
     }
 }
Exemplo n.º 5
0
    void DrawFromDeck()
    {
        GameObject newCard  = Instantiate(Resources.Load("Prefabs/Card")) as GameObject;
        string     cardPath = stringDeck.Pop();

        newCard.GetComponent <SpriteRenderer>().sprite = (Sprite)AssetDatabase.LoadAssetAtPath(cardPath, typeof(Sprite));
        CardInteraction cardInteraction = newCard.GetComponent <CardInteraction>();

        cardInteraction.hover = true;
        cardInteraction.drag  = true;
        Vector3 mousePosition = getMouseWorldPosition();

        newCard.GetComponent <Transform>().position = new Vector3(mousePosition.x, mousePosition.y, 0);
    }
Exemplo n.º 6
0
 public void ChangeHandCardCostImpl(int PawnBoardFieldId)
 {
     if (pawn.gamePlayComp.HandComp != null)
     {
         foreach (GameObject cardOb in pawn.gamePlayComp.HandComp.HandCards)
         {
             if (cardOb != null)
             {
                 CardInteraction card = cardOb.GetComponent <CardInteraction> ();
                 if (card != null)
                 {
                     card.SetCardCost(card.CardCost + costChange);
                 }
             }
         }
     }
 }
Exemplo n.º 7
0
    void InstantiateDeck()
    {
        // Go through each card
        foreach (Card card in myDeck)
        {
            /*
             * // Get random Y-pos within the boundaries of the main camera
             * float spawnY =
             *  Random.Range(
             *      Camera.main.ScreenToWorldPoint(
             *          new Vector2(0, 0)).y,
             *      Camera.main.ScreenToWorldPoint(
             *          new Vector2(0, Screen.height)).y
             *  );
             * // Get random X-pos within the boundaries of the main camera
             * float spawnX =
             *  Random.Range(
             *      Camera.main.ScreenToWorldPoint(
             *          new Vector2(0, 0)).x,
             *      Camera.main.ScreenToWorldPoint(
             *          new Vector2(Screen.width, 0)).x
             *  );
             *
             * // Create a vector two based on the above X and Y values
             * Vector2 spawnPosition = new Vector2(spawnX, spawnY);
             */

            // Instantiate the card on screen at our random position
            GameObject newCard = (GameObject)Instantiate(
                Resources.Load(
                    "Cards/Card"
                    ),
                new Vector2(0, 0),
                Quaternion.Euler(0, 0, Random.Range(0, 360))
                );


            CardInteraction newCardValues = newCard.GetComponentInChildren <CardInteraction>();

            newCardValues.mySuit  = card.mySuit;
            newCardValues.myRule  = card.myRule;
            newCardValues.myValue = card.myValue;
        }
    }
Exemplo n.º 8
0
    public bool ChooseCard(int index, CardInteraction cardInteraction)
    {
        Card cardToUse     = hand[index];
        bool cardCanBeUsed = GameController.Instance.TryUseCard(this, cardToUse);

        if (!cardCanBeUsed)
        {
            return(false);
        }

        hand.RemoveAt(index);
        cardObjects.RemoveAt(index);
        cardInteraction.MoveToUsedCards();

        SortHand();
        RefreshCardsObjects();
        SetInteractivity(false);

        return(true);
    }
Exemplo n.º 9
0
    void RefreshCardsObjects()
    {
        while (cardObjects.Count > 0)
        {
            cardObjects[0].GetComponent <PoolSignature>().ReturnToPool();
            cardObjects.RemoveAt(0);
        }

        Vector3 cardPosition = -new Vector3((hand.Count - 1) * imageWidth / 2, 0.0f, 0.0f);
        Vector3 distanceBetweenCards;
        //checks if the distance between cards should be less than default image width
        bool hasEnoghSpaceForCards = -rTrans.sizeDelta.x / 2 < (cardPosition.x - imageWidth / 2);

        if (hasEnoghSpaceForCards)
        {
            distanceBetweenCards = new Vector3(imageWidth, 0.0f, 0.0f);
        }
        else
        {
            cardPosition.x       = -rTrans.sizeDelta.x / 2 + imageWidth / 2;
            distanceBetweenCards = new Vector3((rTrans.sizeDelta.x - imageWidth) / (hand.Count - 1), 0.0f, 0.0f);
        }

        for (int i = 0; i < hand.Count; i++, cardPosition += distanceBetweenCards)
        {
            GameObject cardObject = cardImagesPool.GetObject();
            cardObject.transform.SetParent(transform);
            cardObject.SetActive(true);
            cardObject.transform.localPosition = cardPosition;

            CardInteraction interactiveComponent = cardObject.GetComponent <CardInteraction>();
            interactiveComponent.cardHolder        = this;
            interactiveComponent.indexInPlayerDeck = i;

            cardObjects.Add(cardObject);
        }

        SetCardsSprites();
    }
Exemplo n.º 10
0
 public void RemoveCards(IList<CardView> cards)
 {
     foreach (var card in cards)
     {
         if (card == _interactingCard)
         {
             _interactingCard = null;
             _cardInteraction = CardInteraction.None;
         }
         UnregisterCardEvents(card);
     }
     var nonexisted = new List<CardView>(
                         from c in cards
                         where !_cards.Contains(c)
                         select c);
     var space = MaxCardSpacing;
     MaxCardSpacing = 30;
     RearrangeCards(nonexisted);
     MaxCardSpacing = space;
     if (nonexisted.Count != cards.Count)
     {
         _cards = new List<CardView>(_cards.Except(cards));
         RearrangeCards(_cards);
     }
 }
Exemplo n.º 11
0
 private void card_MouseLeaveUnlock()
 {
     _cardInteraction = CardInteraction.None;
     _interactingCard = null;
     RearrangeCards(0.2d);
 }
Exemplo n.º 12
0
    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();
                }
            }
        }
    }
Exemplo n.º 13
0
 void card_OnDragEndUnlock()
 {
     Trace.TraceInformation("DragEnd");
     _cardInteraction = CardInteraction.None;
     int newPos = _ComputeDragCardNewIndex();
     int oldPos = _cards.IndexOf(_interactingCard);
     if (newPos != oldPos)
     {
         _cards.Remove(_interactingCard);
         _cards.Insert(newPos, _interactingCard);
         var handler = OnHandCardMoved;
         if (handler != null)
         {
             handler(oldPos, newPos);
         }
     }
     RearrangeCards(0.2d);
 }
Exemplo n.º 14
0
 void card_OnDragEnd(object sender, EventArgs e)
 {
     if (_cardInteraction == CardInteraction.Drag)
     {
         lock (_cards)
         {
             card_OnDragEndUnlock();
         }
         _cardInteraction = CardInteraction.MouseMove;
     }
 }
Exemplo n.º 15
0
 void card_OnDragBegin(object sender, EventArgs e)
 {
     if (_cardInteraction == CardInteraction.MouseMove)
     {
         lock (_cards)
         {
             Trace.TraceInformation("DragBegin");
             _interactingCard = sender as CardView;
             _interactingCard.SetValue(Canvas.ZIndexProperty, 1000);
             Trace.Assert(_interactingCard != null);
             _cardInteraction = CardInteraction.Drag;
             RearrangeCards(0.2d);
         }
     }
 }
Exemplo n.º 16
0
    public GameObject SpawnCard(CardDescriptionClass CardDescription, bool build_mode)
    {
        GameObject      Card;
        CardInteraction CardInteraction;
        GameObject      Pawn;
        Pawn            PawnComponent;
        SpriteRenderer  cardSpriteRenderer;

        if (!CardDescription.CardEnabled)
        {
            return(null);
        }

        Card = (GameObject)Instantiate(CardPrefab, new Vector3(0, 0, 0), Quaternion.identity);
        Pawn = Card.transform.Find("Pawn").gameObject;
        Pawn.GetComponent <SpriteRenderer> ().sprite = CardDescription.Background;
        Pawn.transform.Find("Character").gameObject.GetComponent <SpriteRenderer> ().sprite = CardDescription.Character;
        cardSpriteRenderer = Card.GetComponent <SpriteRenderer> ();

        PawnComponent          = Pawn.GetComponent <Pawn> ();
        PawnComponent.CardID   = CardDescription.CardID;
        PawnComponent.Name     = CardDescription.Name;
        PawnComponent.Desc     = CardDescription.Description;
        PawnComponent.CardType = CardDescription.CardMode;

        PawnComponent.SetAttack(CardDescription.Attack);
        PawnComponent.SetHealth(CardDescription.Health);
        PawnComponent.SetConfig(CardDescription.PawnConfig, CardDescription.SpecialMovement);
        PawnComponent.ApplyConfig();
        PawnComponent.ItemApplyConfig = CardDescription.ItemChangePawnConfig;
        PawnComponent.ItemMergeConfig = CardDescription.ItemMergePawnConfig;

        if (CardDescription.BulletParticlePrefab != null)
        {
            PawnComponent.ShotParticlePrefab = CardDescription.BulletParticlePrefab;
        }
        PawnComponent.ShootingMode  = CardDescription.ShootingMode;
        PawnComponent.ShootInterval = CardDescription.ShootInterval;

        PawnComponent.PawnEffectParameters = CardDescription.EffectParameters;
        PawnComponent.PawnEffectParticle   = CardDescription.EffectParticles;
        if (CardDescription.DeathSound != null)
        {
            PawnComponent.DeathSound = CardDescription.DeathSound;
        }

        CardInteraction = Card.GetComponent <CardInteraction> ();
        CardInteraction.SetName(CardDescription.Name);
        CardInteraction.SetDescription(CardDescription.Description);
        CardInteraction.SetCardCost(CardDescription.Cost);
        CardInteraction.SetCardOrder(1);
        CardInteraction.CardRole   = CardDescription.Role;
        CardInteraction.CardRarity = CardDescription.Rarity;

        if (CardDescription.CardMode == CardTypesEnum.Pawn)
        {
            CardInteraction.SetTypeDescText("Postać");
        }
        else if (CardDescription.CardMode == CardTypesEnum.Weapon)
        {
            CardInteraction.SetTypeDescText("Ekwipunek");
        }
        else if (CardDescription.CardMode == CardTypesEnum.Effect)
        {
            CardInteraction.SetTypeDescText("Efekt");
        }

        if (CardDescription.Rarity == CardInteraction.CardRarityEnum.common)
        {
            cardSpriteRenderer.sprite = SilverCardSprite;
        }
        else if (CardDescription.Rarity == CardInteraction.CardRarityEnum.gold)
        {
            cardSpriteRenderer.sprite = GoldCardSprite;
        }
        else if (CardDescription.Rarity == CardInteraction.CardRarityEnum.diamond)
        {
            cardSpriteRenderer.sprite = DiamondCardSprite;
        }

        if (!build_mode)
        {
            if (CardDescription.EffectComponent.Length > 0)
            {
                Type componentType = Type.GetType(CardDescription.EffectComponent);
                if (componentType != null)
                {
                    Pawn.AddComponent(componentType);
                }
                else
                {
                    Debug.LogWarning("You are missing to add component class named: " + CardDescription.EffectComponent);
                }
            }
        }

        Card.SetActive(true);

        return(Card);
    }
Exemplo n.º 17
0
    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);
    }
Exemplo n.º 18
0
 void card_MouseEnter(object sender, MouseEventArgs e)
 {
     if (_cardInteraction == CardInteraction.None)
     {
         lock (_cards)
         {
             Trace.TraceInformation("MouseEnter");
             _interactingCard = sender as CardView;
             if (_interactingCard != null)
             {
                 _cardInteraction = CardInteraction.MouseMove;
                 RearrangeCards(0.2d);
             }
         }
     }
 }