Exemple #1
0
        public ComboMaxResult GetMaxCombo(List <Die> dice, bool is_sorted)
        {
            if (dice == null)
            {
                return(null);
            }
            List <Die> dice_copy = dice;

            ComboMaxResult result = new ComboMaxResult();

            result.Name  = "Flash Royale";
            result.Score = 350;

            int limit = 5;

            for (int i = 0; i < dice_copy.Count && limit > 0; ++i)
            {
                if (dice_copy[i].Side == DieSide.ONE)
                {
                    --limit;
                    result.DiceInCombo.Add(dice_copy[i]);
                }
            }
            if (limit == 0)
            {
                return(result);
            }
            return(null);
        }
Exemple #2
0
        public ComboMaxResult GetMaxCombo(List <Die> dice, bool is_sorted)
        {
            if (dice == null)
            {
                return(null);
            }
            List <Die> dice_copy = dice;

            if (!is_sorted)
            {
                dice_copy = new List <Die>(dice);
                dice_copy.Sort((d1, d2) => { return((int)d1.Side - (int)d2.Side); });
            }

            byte[]         found_combo_sides = new byte[6];
            ComboMaxResult result            = new ComboMaxResult();

            result.Name = "Flash of ";
            for (int i = 0; i < dice_copy.Count; ++i)
            {
                Die die = dice_copy[i];
                if (die.Side == DieSide.JOKER || die.Side == DieSide.ONE)
                {
                    continue;
                }
                ++found_combo_sides[(int)die.Side];
            }


            DieSide best_side    = DieSide.ONE;
            bool    combo_exists = false;

            for (int i = 5; i > 0; --i)
            {
                if (found_combo_sides[i] >= 5)
                {
                    best_side    = (DieSide)(i);
                    result.Score = (i + 1) * 40;
                    result.Name += Convert.ToString(i + 1);
                    combo_exists = true;
                    break;
                }
            }

            if (!combo_exists)
            {
                return(null);
            }

            for (int i = 0, limit = 5; i < dice_copy.Count && limit > 0; ++i)
            {
                if (dice_copy[i].Side == best_side)
                {
                    --limit;
                    result.DiceInCombo.Add(dice_copy[i]);
                }
            }
            return(result);
        }
        public ComboMaxResult GetMaxCombo(List <Die> dice, bool is_sorted)
        {
            List <Die> dice_copy = dice;

            byte[]         found_combo_sides = new byte[6];
            ComboMaxResult result            = new ComboMaxResult();

            result.Name = "Five-Street up to ";
            for (int i = 0; i < dice_copy.Count; ++i)
            {
                Die die = dice_copy[i];
                if (die.Side == DieSide.JOKER)
                {
                    continue;
                }
                ++found_combo_sides[(int)die.Side];
            }

            bool is_up_to_5 = false;

            for (int i = 5; i >= 1; --i)
            {
                if (found_combo_sides[i] == 0)
                {
                    for (int j = 4; j >= 0; --j)
                    {
                        if (found_combo_sides[j] == 0)
                        {
                            return(null);
                        }
                    }
                    result.Name += "5";
                    result.Score = 100;
                    is_up_to_5   = true;
                }
            }
            result.Name += "6";
            result.Score = 200;
            int cur_side = 0, limit = 4;

            if (is_up_to_5)
            {
                cur_side = 1;
                limit    = 5;
            }

            for (int i = cur_side; i <= limit; ++i)
            {
                result.DiceInCombo.Add(
                    dice_copy.Find((e) => e.Side == (DieSide)i)
                    );
            }

            return(result);
        }
Exemple #4
0
        public static AllCombosInDice ParseDice(List <Die> dice, bool is_sorted)
        {
            if (dice == null)
            {
                return(null);
            }
            List <Die> dice_copy = new List <Die>(dice);

            if (!is_sorted)
            {
                dice_copy = new List <Die>(dice);
                dice_copy.Sort((d1, d2) => { return((int)d1.Side - (int)d2.Side); });
            }

            List <ComboMaxResult> accum = new List <ComboMaxResult>();
            int            accum_score = 0;
            ComboMaxResult cur_result, best_result = null;

            do
            {
                best_result = null;
                int max_score = int.MinValue;
                foreach (ICombo combo_type in _combos)
                {
                    cur_result = combo_type.GetMaxCombo(dice_copy, true);
                    if (cur_result?.Score > max_score)
                    {
                        max_score   = cur_result.Score;
                        best_result = cur_result;
                    }
                }
                if (best_result != null)
                {
                    accum_score += max_score;
                    accum.Add(best_result);
                    dice_copy.RemoveAll((e) => best_result.DiceInCombo.Contains(e));
                }
            } while (best_result != null);
            if (accum_score == 0)
            {
                return(null);
            }
            return(new AllCombosInDice(accum, accum_score));
        }
Exemple #5
0
        public ComboMaxResult GetMaxCombo(List <Die> dice, bool is_sorted)
        {
            List <Die> dice_copy = dice;

            byte[]         found_combo_sides = new byte[6];
            ComboMaxResult result            = new ComboMaxResult();

            for (int i = 0; i < dice_copy.Count; ++i)
            {
                Die die = dice_copy[i];
                if (die.Side == DieSide.JOKER)
                {
                    continue;
                }
                ++found_combo_sides[(int)die.Side];
            }

            int     search_count = 1;
            DieSide search_for   = DieSide.ONE;
            bool    combo_exists = true;

            if (found_combo_sides[0] >= 2)
            {
                result.Score = 20;
                result.Name  = "1+1";
                search_count = 2;
            }
            else if (found_combo_sides[0] == 1)
            {
                result.Score = 10;
                result.Name  = "1";
            }
            else
            {
                search_for = DieSide.FIVE;
                if (found_combo_sides[4] >= 2)
                {
                    result.Score = 10;
                    result.Name  = "5+5";
                    search_count = 2;
                }
                else if (found_combo_sides[4] == 1)
                {
                    result.Score = 5;
                    result.Name  = "5";
                }
                else
                {
                    combo_exists = false;
                }
            }
            if (!combo_exists)
            {
                return(null);
            }
            for (int i = 0; i < dice_copy.Count && search_count > 0; ++i)
            {
                Die die = dice_copy[i];
                if (die.Side == search_for)
                {
                    result.DiceInCombo.Add(die);
                    --search_count;
                }
            }
            return(result);
        }