Example #1
0
        private RefineResults BuildRefineResults(IRefinableItem item, RefineCounts counts, RefineCosts costs)
        {
            var results = new RefineResults();

            results.Successes     = counts.Successes;
            results.Attempts      = counts.Attempts;
            results.RepairedItems = counts.RepairedItems;
            results.BrokenItems   = counts.BrokenItems;

            results.RefinedItemCost = costs.ItemCost;

            foreach (var prop in counts.GetType().GetProperties().Where(x => x.Name.Contains("Consumed")))
            {
                results.ConsumableCounts.Add(prop.Name.Replace("Consumed", ""), (long)prop.GetValue(counts));
            }

            foreach (var prop in counts.GetType().GetProperties().Where(x => x.Name.Contains("Services")))
            {
                results.NpcRefineCounts.Add(prop.Name.Replace("Services", ""), (long)prop.GetValue(counts));
            }

            foreach (var kvp in results.ConsumableCounts.Where(x => x.Value > 0))
            {
                results.ConsumableCosts.Add(kvp.Key, kvp.Value * costs.ConsumableCosts[kvp.Key]);
            }

            foreach (var kvp in results.NpcRefineCounts.Where(x => x.Value > 0))
            {
                results.NpcRefineCosts.Add(kvp.Key, kvp.Value * costs.NpcRefineCosts[kvp.Key]);
            }

            switch (item)
            {
            case LevelOneWeapon _:
                results.NpcRepairCost = results.RepairedItems * (500000 + 2 * costs.ConsumableCosts["Bradium"] + 10 * costs.ConsumableCosts["Oridecon"] + 5 * costs.ConsumableCosts["GoldCoin"]);
                break;

            case LevelTwoWeapon _:
                results.NpcRepairCost = results.RepairedItems * (5000000 + 5 * costs.ConsumableCosts["Bradium"] + 25 * costs.ConsumableCosts["Oridecon"] + 10 * costs.ConsumableCosts["GoldCoin"]);
                break;

            case LevelThreeWeapon _:
                results.NpcRepairCost = results.RepairedItems * (40000000 + 40 * costs.ConsumableCosts["Bradium"] + 80 * costs.ConsumableCosts["Oridecon"] + 50 * costs.ConsumableCosts["GoldCoin"]);
                break;

            case LevelFourWeapon _:
                results.NpcRepairCost = results.RepairedItems * (50000000 + 50 * costs.ConsumableCosts["Bradium"] + 100 * costs.ConsumableCosts["Oridecon"] + 75 * costs.ConsumableCosts["GoldCoin"]);
                break;

            case Armor _:
                results.NpcRepairCost = results.RepairedItems * (5000000 + 5 * costs.ConsumableCosts["Carnium"] + 50 * costs.ConsumableCosts["Elunium"] + 10 * costs.ConsumableCosts["GoldCoin"]);
                break;
            }

            return(results);
        }
Example #2
0
        public RefineResults Run(RefineSimulationParameters parameters, RefineCosts costs)
        {
            var refiner = new Refiner(parameters.Item, parameters.StartingLevel, parameters.RefineSteps);
            var counts  = new RefineCounts();

            for (int i = 0; i < parameters.Attempts; i++)
            {
                refiner.Item.ItemState   = ItemState.Valid;
                refiner.Item.RefineLevel = parameters.StartingLevel;

                while (refiner.Item.RefineLevel < parameters.SuccessLevel && refiner.Item.ItemState == ItemState.Valid)
                {
                    var method = parameters.RefineSteps[refiner.Item.RefineLevel];
                    refiner.RefineItem();

                    TickRefineCounts(counts, method, refiner.Item);

                    if (refiner.Item.ItemState == ItemState.Broken)
                    {
                        counts.BrokenItems++;
                        if (parameters.RepairOnBroken)
                        {
                            refiner.Item.ItemState = ItemState.Valid;
                            counts.RepairedItems++;
                        }
                        else // Downgrade
                        {
                            refiner.Item.RefineLevel = 9;
                            refiner.Item.ItemState   = ItemState.Valid;
                        }
                    }
                }

                if (refiner.Item.RefineLevel == parameters.SuccessLevel && refiner.Item.ItemState == ItemState.Valid)
                {
                    counts.Successes++;
                }

                counts.Attempts++;
            }

            return(BuildRefineResults(parameters.Item, counts, costs));
        }
Example #3
0
        private void TickRefineCounts(RefineCounts counts, RefineMethod method, IRefinableItem item)
        {
            switch (method)
            {
            case RefineMethod.Phracon:
                counts.PhraconConsumed++;
                counts.PhraconServices++;
                break;

            case RefineMethod.WhitesmithPhracon:
                counts.PhraconConsumed++;
                break;

            case RefineMethod.Emveretarcon:
                counts.EmveretarconConsumed++;
                counts.EmveretarconServices++;
                break;

            case RefineMethod.WhitesmithEmveretarcon:
                counts.EmveretarconConsumed++;
                break;

            case RefineMethod.Oridecon:
                counts.OrideconConsumed++;
                if (item is LevelThreeWeapon)
                {
                    counts.Oridecon3Services++;
                }
                else if (item is LevelFourWeapon)
                {
                    counts.Oridecon4Services++;
                }
                break;

            case RefineMethod.WhitesmithOridecon:
                counts.OrideconConsumed++;
                break;

            case RefineMethod.Elunium:
                counts.EluniumConsumed++;
                counts.EluniumServices++;
                break;

            case RefineMethod.EnrichedOridecon:
                counts.EnrichedOrideconConsumed++;
                if (item is LevelThreeWeapon)
                {
                    counts.EnrichedOridecon3Services++;
                }
                else if (item is LevelFourWeapon)
                {
                    counts.EnrichedOridecon4Services++;
                }
                break;

            case RefineMethod.EnrichedElunium:
                counts.EnrichedEluniumConsumed++;
                counts.EnrichedEluniumServices++;
                break;

            case RefineMethod.Carnium:
                counts.CarniumConsumed++;
                counts.CarniumServices++;
                break;

            case RefineMethod.Bradium:
                counts.BradiumConsumed++;
                counts.BradiumServices++;
                break;

            case RefineMethod.HDCarnium:
                counts.HDCarniumConsumed++;
                counts.HDCarniumServices++;
                break;

            case RefineMethod.HDBradium:
                counts.HDBradiumConsumed++;
                counts.HDBradiumServices++;
                break;
            }
        }