示例#1
0
        public List <LootBagTypeDefinition> DetermineBagTypes(int numberOfBags)
        {
            // Define the types of bags to give
            var lootBagDefinitions = new LootBagTypeDefinition().BuildLootBagTypeDefinitions(numberOfBags);

            Logger.Debug($"Number loot bags {lootBagDefinitions.Count} to award.");

            return(lootBagDefinitions);
        }
示例#2
0
        /// <summary>
        /// Builds the bag containing the players items.
        /// </summary>
        /// <returns></returns>
        public KeyValuePair <Item_Info, List <Talisman> > BuildChestLootBag(LootBagRarity rarity, uint itemId, Player player)
        {
            var lootRewardDescription = string.Empty;
            // Get the bag item id
            var lootBagItemId = Convert.ToInt32(LootBagTypeDefinition.GetDescription(rarity));
            // Get the bag item object
            var lootBagItem     = ItemService.GetItem_Info(itemId);
            var lootBagContents = new List <Talisman>
            {
                new Talisman(itemId, (byte)1, 0, 0)
            };

            return(new KeyValuePair <Item_Info, List <Talisman> >(lootBagItem, lootBagContents));
        }
示例#3
0
        /// <summary>
        /// Builds the bag containing the players items.
        /// </summary>
        /// <param name="lootBag"></param>
        /// <param name="player"></param>
        /// <param name="playerRenownBand"></param>
        /// <returns></returns>
        public KeyValuePair <Item_Info, List <Talisman> > BuildChestLootBag(LootBagTypeDefinition lootBag, Player player)
        {
            var lootRewardDescription = string.Empty;
            // Get the bag item id
            var lootBagItemId = Convert.ToInt32(LootBagTypeDefinition.GetDescription(lootBag.BagRarity));
            // Get the bag item object
            var lootBagItem     = ItemService.GetItem_Info((uint)lootBagItemId);
            var lootBagContents = new List <Talisman>
            {
                new Talisman(lootBag.ItemId, (byte)lootBag.ItemCount, 0, 0)
            };

            // RewardLogger.Info($"Distributing reward of {lootBagItem.Name}, containing {lootBag.ItemId} ({lootBag.ItemCount}) to {player.Name}. Result = {result}");

            return(new KeyValuePair <Item_Info, List <Talisman> >(lootBagItem, lootBagContents));
        }
        /// <summary>
        /// Given a lootbag assigned to a player, their class, RR Band and existing items, select a reward for them
        /// </summary>
        /// <param name="lootBag"></param>
        /// <param name="playerRRBand"></param>
        /// <param name="playerClass"></param>
        /// <param name="playerItems"></param>
        /// <param name="shuffleRewards"></param>
        /// <returns></returns>
        public LootBagTypeDefinition SelectBagContentForPlayer(ILogger logger, LootBagTypeDefinition lootBag, byte playerRRBand, int playerClass, List <uint> playerItems, bool shuffleRewards = true)
        {
            logger.Debug($"SelectBagContentForPlayer. Assignee {lootBag.Assignee} Rarity {lootBag.BagRarity} Player RR Band {playerRRBand} Class {playerClass} Shuffle {shuffleRewards} ");
            // get a closer list of matching items.
            var matchingRewards = RVRRewards.Where(x => lootBag.BagRarity == (LootBagRarity)x.Rarity);

            logger.Debug($"Matching Rewards = {matchingRewards.Count()}");
            if (matchingRewards == null)
            {
                return(lootBag);
            }

            if (matchingRewards.Count() == 0)
            {
                return(lootBag);
            }

            if (shuffleRewards)
            {
                matchingRewards = matchingRewards.OrderBy(a => RandomGenerator.Next()).ToList();
            }

            // Filter rewards to match the player's need
            var rrBandMatches = matchingRewards.Where(x => x.RRBand == 0 || x.RRBand == playerRRBand);

            logger.Debug($"rrBandMatches Rewards = {rrBandMatches.Count()}");
            var rrClassMatches = rrBandMatches.Where(x => x.Class == 0 || x.Class == playerClass);

            logger.Debug($"rrClassMatches Rewards = {rrClassMatches.Count()}");

            // Works but not good for unit tests
            //matchingRewards = matchingRewards.OrderBy(a => Guid.NewGuid()).ToList();

            foreach (var matchingReward in rrClassMatches)
            {
                // Does this matching reward exist in player's items? And we cannot duplicate move on.
                if (playerItems.Count(x => x == matchingReward.ItemId) > 0)
                {
                    logger.Debug($"Duplicate found...");
                    if (matchingReward.CanAwardDuplicate == 0)
                    {
                        logger.Debug($"Player {lootBag.Assignee} has item {matchingReward.ItemId} already...skipping");
                        continue;
                    }
                    else
                    {
                        logger.Debug($"Player {lootBag.Assignee} has item {matchingReward.ItemId} already...but duplicates are allowed.");
                        lootBag.ItemCount  = (uint)matchingReward.ItemCount;
                        lootBag.ItemId     = (uint)matchingReward.ItemId;
                        lootBag.RenownBand = playerRRBand;
                        break;
                    }
                }
                else
                {
                    logger.Debug($"Player {lootBag.Assignee} does not have item {matchingReward.ItemId} already...assigning");
                    lootBag.ItemCount  = (uint)matchingReward.ItemCount;
                    lootBag.ItemId     = (uint)matchingReward.ItemId;
                    lootBag.RenownBand = playerRRBand;
                    break;
                }
            }

            return(lootBag);
        }