Esempio n. 1
0
        public void initialize(GameLogic.ChestType chestType)
        {
            this.ChestType = chestType;
            ChestBlueprint blueprint = ConfigUi.CHEST_BLUEPRINTS[chestType];
            LootTable      table     = GameLogic.Binder.ItemResources.getDynamicChestLootTable(chestType);
            List <Item>    list      = new List <Item>(table.Items.Count);

            for (int i = 0; i < table.Items.Count; i++)
            {
                LootTableItem item = table.Items[i];
                if (!GameLogic.Binder.ItemResources.itemExists(item.Id))
                {
                    Debug.LogError("Only fixed item visualization supported for chests: " + item.Id);
                }
                else
                {
                    Item item2 = GameLogic.Binder.ItemResources.getItemForLootTableRollId(item.Id, ItemType.UNSPECIFIED);
                    list.Add(item2);
                }
            }
            list.Sort(this.m_chestContentComparer);
            for (int j = 0; j < list.Count; j++)
            {
                Item             item3  = list[j];
                SpriteAtlasEntry sprite = new SpriteAtlasEntry("Menu", item3.SpriteId);
                this.addItemToGrid(item3, item3.Rarity, sprite);
            }
            this.Title.text = _.L(blueprint.Name, null, false);
            this.setupChest(chestType);
        }
Esempio n. 2
0
        public static ItemVO PickRandomItemFromLootTable(int lootTableID)
        {
            if (lootTableID <= 0)
            {
                return(null);
            }
            var lootTableItems = DataService.LootTableItem.GetAllByLootTableID(lootTableID).ToList();

            if (lootTableItems.Count <= 0)
            {
                return(null);
            }
            int[] weights = new int[lootTableItems.Count];
            for (int x = 0; x < lootTableItems.Count; x++)
            {
                weights[x] = lootTableItems.ElementAt(x).Weight;
            }

            int           randomIndex = RandomService.GetRandomWeightedIndex(weights);
            LootTableItem itemEntity  = lootTableItems.ElementAt(randomIndex);
            int           quantity    = RandomService.Random(itemEntity.MaxQuantity) + 1;
            ItemVO        result      = new ItemVO
            {
                Quantity  = quantity,
                Resref    = itemEntity.Resref,
                SpawnRule = itemEntity.SpawnRule
            };

            return(result);
        }
Esempio n. 3
0
        public ItemVO PickRandomItemFromLootTable(int lootTableID)
        {
            if (lootTableID <= 0)
            {
                return(null);
            }

            LootTable entity = _db.LootTables.Single(x => x.LootTableID == lootTableID);

            if (entity.LootTableItems.Count <= 0)
            {
                return(null);
            }

            int[] weights = new int[entity.LootTableItems.Count];

            for (int x = 0; x < entity.LootTableItems.Count; x++)
            {
                weights[x] = entity.LootTableItems.ElementAt(x).Weight;
            }
            int randomIndex = _random.GetRandomWeightedIndex(weights);

            LootTableItem itemEntity = entity.LootTableItems.ElementAt(randomIndex);
            int           quantity   = _random.Random(itemEntity.MaxQuantity) + 1;

            ItemVO result = new ItemVO
            {
                Quantity = quantity,
                Resref   = itemEntity.Resref
            };


            return(result);
        }
Esempio n. 4
0
        public void GetByID_OneItem_ReturnsLootTableItem()
        {
            // Arrange
            LootTableItem entity = new LootTableItem {
                ID = 1
            };

            // Act
            MessageHub.Instance.Publish(new OnCacheObjectSet <LootTableItem>(entity));

            // Assert
            Assert.AreNotSame(entity, _cache.GetByID(1));
        }
        private LootTable prepareDynamicChestTable(ChestType chestType)
        {
            LootTable table = GameLogic.Binder.ItemResources.getDynamicChestLootTable(chestType);

            for (int i = 0; i < table.Items.Count; i++)
            {
                LootTableItem lti   = table.Items[i];
                Item          item2 = GameLogic.Binder.ItemResources.getItemForLootTableRollId(lti.Id, ItemType.UNSPECIFIED);
                if (item2 != null)
                {
                    int weight = App.Binder.ConfigLootTables.UniversalItemRarityWeights[item2.Rarity];
                    table.setWeightForItem(lti, weight);
                }
            }
            return(table);
        }
Esempio n. 6
0
        public void GetByID_TwoItems_ReturnsCorrectObject()
        {
            // Arrange
            LootTableItem entity1 = new LootTableItem {
                ID = 1
            };
            LootTableItem entity2 = new LootTableItem {
                ID = 2
            };

            // Act
            MessageHub.Instance.Publish(new OnCacheObjectSet <LootTableItem>(entity1));
            MessageHub.Instance.Publish(new OnCacheObjectSet <LootTableItem>(entity2));

            // Assert
            Assert.AreNotSame(entity1, _cache.GetByID(1));
            Assert.AreNotSame(entity2, _cache.GetByID(2));
        }
Esempio n. 7
0
        public void GetByID_RemovedItem_ReturnsCorrectObject()
        {
            // Arrange
            LootTableItem entity1 = new LootTableItem {
                ID = 1
            };
            LootTableItem entity2 = new LootTableItem {
                ID = 2
            };

            // Act
            MessageHub.Instance.Publish(new OnCacheObjectSet <LootTableItem>(entity1));
            MessageHub.Instance.Publish(new OnCacheObjectSet <LootTableItem>(entity2));
            MessageHub.Instance.Publish(new OnCacheObjectDeleted <LootTableItem>(entity1));

            // Assert
            Assert.Throws <KeyNotFoundException>(() => { _cache.GetByID(1); });
            Assert.AreNotSame(entity2, _cache.GetByID(2));
        }
Esempio n. 8
0
        public void GetByID_NoItems_ThrowsKeyNotFoundException()
        {
            // Arrange
            LootTableItem entity1 = new LootTableItem {
                ID = 1
            };
            LootTableItem entity2 = new LootTableItem {
                ID = 2
            };

            // Act
            MessageHub.Instance.Publish(new OnCacheObjectSet <LootTableItem>(entity1));
            MessageHub.Instance.Publish(new OnCacheObjectSet <LootTableItem>(entity2));
            MessageHub.Instance.Publish(new OnCacheObjectDeleted <LootTableItem>(entity1));
            MessageHub.Instance.Publish(new OnCacheObjectDeleted <LootTableItem>(entity2));

            // Assert
            Assert.Throws <KeyNotFoundException>(() => { _cache.GetByID(1); });
            Assert.Throws <KeyNotFoundException>(() => { _cache.GetByID(2); });
        }
Esempio n. 9
0
        private ItemVO PickResultItem(int lootTableID)
        {
            var lootTableItems = _data.Where <LootTableItem>(x => x.LootTableID == lootTableID).ToList();

            int[] weights = new int[lootTableItems.Count];

            for (int x = 0; x < lootTableItems.Count; x++)
            {
                weights[x] = lootTableItems.ElementAt(x).Weight;
            }
            int randomIndex = _random.GetRandomWeightedIndex(weights);

            LootTableItem itemEntity = lootTableItems.ElementAt(randomIndex);
            int           quantity   = _random.Random(itemEntity.MaxQuantity) + 1;

            ItemVO result = new ItemVO
            {
                Quantity = quantity,
                Resref   = itemEntity.Resref
            };

            return(result);
        }