init

Assets/TcgEngine/Scripts/Menu/OpenPackMenu.cs

@@ -0,0 +1,243 @@
+using System.Collections;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using UnityEngine;
+
+namespace TcgEngine.Client
+{
+    /// <summary>
+    /// Main script for the open pack scene
+    /// </summary>
+
+    public class OpenPackMenu : MonoBehaviour
+    {
+        public GameObject card_prefab;
+
+        private bool revealing = false;
+
+        private static OpenPackMenu instance;
+
+        void Awake()
+        {
+            instance = this;
+        }
+
+        void Update()
+        {
+            if (revealing && Input.GetMouseButtonDown(0))
+            {
+                bool all_revealed = true;
+                foreach (PackCard card in PackCard.GetAll())
+                {
+                    if (!card.IsRevealed())
+                        all_revealed = false;
+                }
+
+                if (all_revealed && PackCard.GetAll().Count > 0)
+                    StopReveal();
+            }
+        }
+
+        public void OpenPack(string pack_tid)
+        {
+            PackData pack = PackData.Get(pack_tid);
+            if (pack != null)
+            {
+                OpenPack(pack);
+            }
+        }
+
+        public void OpenPack(PackData pack)
+        {
+            if (Authenticator.Get().IsApi())
+            {
+                OpenPackApi(pack);
+            }
+            if (Authenticator.Get().IsTest())
+            {
+                OpenPackTest(pack);
+            }
+        }
+        
+        public async void OpenPackTest(PackData pack)
+        {
+            UserData udata = Authenticator.Get().UserData;
+            if (!udata.HasPack(pack.id))
+                return;
+
+            List<UserCardData> cards = new List<UserCardData>();
+            List <CardData> all_cards = CardData.GetAll(pack);
+
+            if (pack.type == PackType.Random)
+            {
+                for (int i = 0; i < pack.cards; i++)
+                {
+                    RarityData rarity = GetRandomRarity(pack, i == 0);
+                    VariantData variant = GetRandomVariant(pack);
+                    List<CardData> vcards = GetCardArray(all_cards, rarity);
+                    if (vcards.Count > 0)
+                    {
+                        CardData card = vcards[Random.Range(0, vcards.Count)];
+                        UserCardData ucard = new UserCardData(card, variant);
+                        cards.Add(ucard);
+                    }
+                }
+            }
+
+            if (pack.type == PackType.Fixed)
+            {
+                for (int i = 0; i < Mathf.Min(pack.cards, all_cards.Count); i++)
+                {
+                    CardData card = all_cards[i];
+                    VariantData variant = VariantData.GetDefault();
+                    UserCardData ucard = new UserCardData(card, variant);
+                    cards.Add(ucard);
+                }
+            }
+
+            //Reveal cards
+            RevealCards(pack, cards.ToArray());
+
+            //Save cards
+            udata.AddPack(pack.id, -1);
+            foreach (UserCardData card in cards)
+            {
+                udata.AddCard(card.tid, card.variant, card.quantity);
+            }
+
+            await Authenticator.Get().SaveUserData();
+            HandPackArea.Get().LoadPacks();
+        }
+
+        public async void OpenPackApi(PackData pack)
+        {
+            UserData udata = Authenticator.Get().UserData;
+            if (!udata.HasPack(pack.id))
+                return;
+
+            udata.AddPack(pack.id, -1);
+
+            OpenPackRequest req = new OpenPackRequest();
+            req.pack = pack.id;
+
+            string url = ApiClient.ServerURL + "/users/packs/open";
+            string json = ApiTool.ToJson(req);
+
+            WebResponse res = await ApiClient.Get().SendPostRequest(url, json);
+            if (res.success)
+            {
+                UserCardData[] cards = ApiTool.JsonToArray<UserCardData>(res.data);
+                RevealCards(pack, cards);
+            }
+
+            HandPackArea.Get().LoadPacks();
+        }
+
+        public void RevealCards(PackData pack, UserCardData[] cards)
+        {
+            UserData udata = Authenticator.Get().UserData;
+            CardbackData cb = CardbackData.Get(udata.cardback);
+            HandPackArea.Get().Lock(true);
+            revealing = true;
+
+            int index = 0;
+            foreach (UserCardData card in cards)
+            {
+                CardData icard = CardData.Get(card.tid);
+                VariantData variant = VariantData.Get(card.variant);
+                if (icard != null && variant != null)
+                {
+                    GameObject cobj = Instantiate(card_prefab, new Vector3(0f, -3f, 0f), Quaternion.identity);
+                    PackCard pcard = cobj.GetComponent<PackCard>();
+                    pcard.SetCard(pack, icard, variant);
+                    BoardRef bref = BoardRef.Get(BoardRefType.PackCard, index);
+                    Vector3 pos = bref != null ? bref.transform.position : Vector3.zero;
+                    pcard.SetTarget(pos);
+                    index++;
+                }
+            }
+        }
+
+        private List<CardData> GetCardArray(List<CardData>  all_cards, RarityData rarity)
+        {
+            List<CardData> cards = new List<CardData>();
+            foreach (CardData acard in all_cards)
+            {
+                if (acard.rarity == rarity)
+                    cards.Add(acard);
+            }
+            return cards;
+        }
+
+        private RarityData GetRandomRarity(PackData pack, bool is_first)
+        {
+            PackRarity[] rarities = is_first ? pack.rarities_1st : pack.rarities;
+            if (rarities == null || rarities.Length == 0)
+                return RarityData.GetFirst();
+
+            int total = 0;
+            foreach (PackRarity rarity in rarities)
+            {
+                total += rarity.probability;
+            }
+
+            int rvalue = Mathf.FloorToInt(Random.value * total);
+            for (int i = 0; i < rarities.Length; i++)
+            {
+                PackRarity rarity = rarities[i];
+                if (rvalue < rarity.probability)
+                {
+                    return rarity.rarity;
+                }
+                rvalue -= rarity.probability;
+            }
+            return RarityData.GetFirst();
+        }
+
+        private VariantData GetRandomVariant(PackData pack)
+        {
+            PackVariant[] variants = pack.variants;
+            if (variants == null || variants.Length == 0)
+                return VariantData.GetDefault();
+
+            int total = 0;
+            foreach (PackVariant variant in variants)
+            {
+                total += variant.probability;
+            }
+
+            int rvalue = Mathf.FloorToInt(Random.value * total);
+            for (int i = 0; i < variants.Length; i++)
+            {
+                PackVariant variant = variants[i];
+                if (rvalue < variant.probability)
+                {
+                    return variant.variant;
+                }
+                rvalue -= variant.probability;
+            }
+            return VariantData.GetDefault();
+        }
+
+        public void StopReveal()
+        {
+            revealing = false;
+            HandPackArea.Get().Lock(false);
+            foreach (PackCard card in PackCard.GetAll())
+            {
+                card.Remove();
+            }
+        }
+
+        public void OnClickBack()
+        {
+            SceneNav.GoTo("Menu");
+        }
+
+        public static OpenPackMenu Get()
+        {
+            return instance;
+        }
+    }
+
+}