Пример #1
0
        BoosterPool getBoosterPoolFromJSON(String JSONFileName)
        {
            BoosterPool new_pool = new BoosterPool();

            new_pool.path = JSONFileName;
            //first, get all respective names


            String json = System.IO.File.ReadAllText(JSONFileName);


            //TODO: read JSON
            List <YGOJSONStruct> json_list = JsonConvert.DeserializeObject <List <YGOJSONStruct> >(json);

            List <String> rares        = extractRarityList(json_list, "rare");
            List <String> super_rares  = extractRarityList(json_list, "super rare");
            List <String> commons      = extractRarityList(json_list, "common");
            List <String> ultra_rares  = extractRarityList(json_list, "ultra rare");
            List <String> secret_rares = extractRarityList(json_list, "secret rare");

            //next get BoosterPool for these names from ygopro database

            new_pool.commons      = query_ygopro_ids(commons);
            new_pool.rares        = query_ygopro_ids(rares);
            new_pool.super_rares  = query_ygopro_ids(super_rares);
            new_pool.ultra_rares  = query_ygopro_ids(ultra_rares);
            new_pool.secret_rares = query_ygopro_ids(secret_rares);



            return(new_pool);
        }
Пример #2
0
        public void pullCardsFromBoosterPoolsAndSend()
        {
            foreach (NetConnection nc in clients)
            {
                client_card_ids[nc] = new List <int>();
                m_dist.ultra_rare   = 1.0f / 6.0f;
                m_dist.super_rare   = 1.0f / 4.0f;
                m_dist.secret_rare  = 1.0f / 12.0f;
                m_dist.rare         = 1 - m_dist.secret_rare - m_dist.super_rare - m_dist.ultra_rare;
                //TODO: can also use a changing counter so booster pools are switched after every draftroun
                for (int idx = 0; idx < m_booster_pools.Count; idx++)
                {
                    if (m_pullOnlyOne && m_packIdx != idx)
                    {
                        continue;
                    }

                    BoosterPool bp        = m_booster_pools[idx];
                    int         num_cards = bp.commons.Count + bp.rares.Count + bp.secret_rares.Count + bp.super_rares.Count + bp.ultra_rares.Count;
                    if (num_cards - m_numCardsPerBooster < 0)
                    {
                        m_booster_pools[idx] = getBoosterPoolFromJSON(bp.path);
                        bp = m_booster_pools[idx];
                    }
                    num_cards = bp.commons.Count + bp.rares.Count + bp.secret_rares.Count + bp.super_rares.Count + bp.ultra_rares.Count;
                    client_card_ids[nc].AddRange(pullFromBoosterPoolWithRarityDistribution(bp, m_remove_from_pool, m_dist, m_numCardsPerBooster, m_numRaresPerBooster));

                    printDebugConsole("Pool: " + bp.path + " | " + num_cards + " Cards left.");
                }

                // printDebugConsole("Found " + m_ygopro_ids.Count + " matches in ygopro database!");
                // printDebugConsole(m_ygopro_ids);


                //send card ids to each client

                var message = nc.Peer.CreateMessage();
                message.Write("DRAFTCARDS");
                var bin = new BinaryFormatter();
                var ser = JsonConvert.SerializeObject(client_card_ids[nc]);
                message.Write(ser);
                server.SendMessage(message, nc, NetDeliveryMethod.ReliableOrdered);
            }
        }
Пример #3
0
        List <int> pullFromBoosterPoolWithRarityDistribution(BoosterPool pool, bool remove_from_pool, RarityDistribution dist, int number_of_cards, int number_of_rares_or_better)
        {
            List <int> ret_list = new List <int>();
            //rarity calc


            //define probability ranges for convenience
            double     rare_bound        = m_dist.rare;
            double     super_rare_bound  = rare_bound + m_dist.super_rare;
            double     ultra_rare_bound  = super_rare_bound + m_dist.ultra_rare;
            double     secret_rare_bound = ultra_rare_bound + m_dist.secret_rare;;
            List <int> all_cards         = new List <int>();

            all_cards.AddRange(pool.commons);
            all_cards.AddRange(pool.rares);
            all_cards.AddRange(pool.super_rares);
            all_cards.AddRange(pool.ultra_rares);
            all_cards.AddRange(pool.secret_rares);
            for (int i = 0; i < number_of_rares_or_better; i++)
            {
                double rng_val = rng.NextDouble();

                //don't care about ultimate/ghost whatever

                if (rng_val <= rare_bound)
                {
                    //rarity = "Rare";
                    //get random card out of rares
                    if (pool.rares.Count == 0)
                    {
                        //card_names.Add(commons[rng.Next(commons.Count)]);
                        //TODO: what if there are no commons? cant fall back. maybe just use a random one.
                        //ret_list.Add(all_cards[rng.Next(all_cards.Count)]);
                        addRandomCardFromPool(ret_list, all_cards, all_cards, remove_from_pool);
                        //card_names.Add(json_list[rng.Next(json_list.Count)].name);
                    }
                    else
                    {
                        //card_names.Add(rares[rng.Next(rares.Count)]);
                        addRandomCardFromPool(ret_list, pool.rares, all_cards, remove_from_pool);
                    }
                }
                else if (rng_val > rare_bound && rng_val <= super_rare_bound)
                {
                    // rarity = "Super Rare";
                    if (pool.super_rares.Count == 0)
                    {
                        if (pool.rares.Count == 0)
                        {
                            addRandomCardFromPool(ret_list, pool.commons, all_cards, remove_from_pool);
                        }
                        else
                        {
                            addRandomCardFromPool(ret_list, pool.rares, all_cards, remove_from_pool);
                        }
                    }
                    else
                    {
                        addRandomCardFromPool(ret_list, pool.super_rares, all_cards, remove_from_pool);
                    }
                }
                else if (rng_val > super_rare_bound && rng_val <= ultra_rare_bound)
                {
                    //rarity = "Ultra Rare";
                    if (pool.ultra_rares.Count == 0)
                    {
                        if (pool.super_rares.Count == 0)
                        {
                            if (pool.rares.Count == 0)
                            {
                                addRandomCardFromPool(ret_list, pool.commons, all_cards, remove_from_pool);
                            }
                            else
                            {
                                addRandomCardFromPool(ret_list, pool.rares, all_cards, remove_from_pool);
                            }
                        }
                        else
                        {
                            addRandomCardFromPool(ret_list, pool.super_rares, all_cards, remove_from_pool);
                        }
                    }
                    else
                    {
                        addRandomCardFromPool(ret_list, pool.ultra_rares, all_cards, remove_from_pool);
                    }
                }
                else
                {
                    // rarity = "Secret Rare";
                    if (pool.secret_rares.Count == 0)
                    {
                        if (pool.ultra_rares.Count == 0)
                        {
                            if (pool.super_rares.Count == 0)
                            {
                                if (pool.rares.Count == 0)
                                {
                                    addRandomCardFromPool(ret_list, pool.commons, all_cards, remove_from_pool);
                                }
                                else
                                {
                                    addRandomCardFromPool(ret_list, pool.rares, all_cards, remove_from_pool);
                                }
                            }
                            else
                            {
                                addRandomCardFromPool(ret_list, pool.super_rares, all_cards, remove_from_pool);
                            }
                        }
                        else
                        {
                            addRandomCardFromPool(ret_list, pool.ultra_rares, all_cards, remove_from_pool);
                        }
                    }
                    else
                    {
                        addRandomCardFromPool(ret_list, pool.secret_rares, all_cards, remove_from_pool);
                    }
                }
            }

            for (int i = 0; i < number_of_cards - number_of_rares_or_better; i++)
            {
                //rest is commons
                if (pool.commons.Count != 0)
                {
                    addRandomCardFromPool(ret_list, pool.commons, all_cards, remove_from_pool);
                }
                else
                {
                    addRandomCardFromPool(ret_list, all_cards, all_cards, remove_from_pool);
                }
            }



            return(ret_list);
        }