Пример #1
0
 public Item_(ItemGeneratorAsset item)
 {
     Item_Name      = item.name;
     Item_FullName  = item.GetNameKey();
     Item_Id        = item.GeneratorId;
     Item_ShortName = GetShortName(item.name);
     Item_Guid      = RuntimeHurtDB.Instance.GetGuid(item);
 }
Пример #2
0
        void GiveItems(Inventory inv)
        {
            int num   = 0;
            int count = Convert.ToInt32(Config["ItemsPerChest"]);

            while (num < count)
            {
                var ItemList = getRarity();
                int rand     = UnityEngine.Random.Range(0, ItemList.Count);
                ItemGeneratorAsset generator = RuntimeHurtDB.Instance.GetObjectByGuid <ItemGeneratorAsset>((string)ItemList.ElementAt(rand).Key);
                GIM.GiveItem(generator, ItemList.ElementAt(rand).Value, inv);
                num++;
            }
        }
Пример #3
0
 private void GetItemList()
 {
     _config.ItemList.Clear();
     Dictionary <int, ItemGeneratorAsset> .Enumerator itemsEnumerator = GlobalItemManager.Instance.GetGenerators().GetEnumerator();
     while (itemsEnumerator.MoveNext())
     {
         ItemGeneratorAsset item = itemsEnumerator.Current.Value;
         Items newItemList       = new Items
         {
             itemId          = item.GeneratorId,
             itemName        = item.ToString(),
             itemFullNameKey = item.GetNameKey(),
             itemGuid        = RuntimeHurtDB.Instance.GetGuid(item)
         };
         _config.ItemList.Add(newItemList);
     }
     SaveConfig();
 }
Пример #4
0
        object GiveKit(PlayerSession session, string kitname)
        {
            Kit kit;

            if (string.IsNullOrEmpty(kitname) || !storedData.Kits.TryGetValue(kitname, out kit))
            {
                return(Msg("MSG_KITNotExist").Replace("{kitname}", kitname));
            }

            var playerinv   = session.WorldPlayerEntity.GetComponent <PlayerInventory>();
            var amanager    = Singleton <AlertManager> .Instance;
            var itemmanager = Singleton <GlobalItemManager> .Instance;

            foreach (var kitem in kit.items)
            {
                if (playerinv.GetSlot(kitem.slot) == null)
                {
                    ItemGeneratorAsset generator = FindItem(kitem.guID.ToString());
                    if (generator == null)
                    {
                        PrintWarning("Something is wrong with the item:" + kitem.guID.ToString());
                        continue;
                    }
                    ItemObject item = itemmanager.CreateItem(generator, kitem.amount);
                    playerinv.SetSlot(kitem.slot, item);
                    amanager.ItemReceivedServer(item, item.StackSize, session.Player);
                    playerinv.Invalidate(false);
                }
                else
                {
                    ItemGeneratorAsset generator = FindItem(kitem.guID.ToString());
                    if (generator == null)
                    {
                        PrintWarning("Something is wrong with the item:" + kitem.guID.ToString());
                        continue;
                    }
                    itemmanager.GiveItem(session.Player, generator, kitem.amount);
                }
            }
            return(true);
        }
Пример #5
0
        ////////////////////////////////////////////////////////////////////////////////////////
        //    Выдаем игроку нужный предмет
        ////////////////////////////////////////////////////////////////////////////////////////

        object GiveItem(PlayerSession session, string itemNameOrIdOrGuid, int amount = 1)
        {
            string             itemName  = itemNameOrIdOrGuid;
            PlayerInventory    inventory = session.WorldPlayerEntity.GetComponent <PlayerInventory>();
            ItemGeneratorAsset generator = FindItem(itemNameOrIdOrGuid);

            if (generator == null)
            {
                PrintWarning("Something is wrong with the item:" + itemNameOrIdOrGuid);
                return(false);
            }

            ItemObject itemObj;

            if (generator.IsStackable())
            {
                itemObj = GlobalItemManager.Instance.CreateItem(generator, amount);
                if (!inventory.GiveItemServer(itemObj))
                {
                    GlobalItemManager.SpawnWorldItem(itemObj, inventory);
                }
            }
            else
            {
                int amountGiven = 0;
                while (amountGiven < amount)
                {
                    itemObj = GlobalItemManager.Instance.CreateItem(generator);
                    if (!inventory.GiveItemServer(itemObj))
                    {
                        GlobalItemManager.SpawnWorldItem(itemObj, inventory);
                    }
                    amountGiven++;
                }
            }

            return(true);
        }
Пример #6
0
        private object GiveItem(IPlayer target, string itemNameOrId, int amount = 1, string container = "main")
        {
            if (config.ItemBlacklist.Contains(itemNameOrId.ToLower()))
            {
                return(null);
            }

            string itemName = itemNameOrId;

#if HURTWORLDITEMV2
            PlayerSession      session   = target.Object as PlayerSession;
            PlayerInventory    inventory = session.WorldPlayerEntity.GetComponent <PlayerInventory>();
            ItemGeneratorAsset generator = FindItem(itemNameOrId);

            ItemObject itemObj;
            if (generator.IsStackable())
            {
                itemObj = GlobalItemManager.Instance.CreateItem(generator, amount);
                if (!inventory.GiveItemServer(itemObj))
                {
                    GlobalItemManager.SpawnWorldItem(itemObj, inventory);
                }
            }
            else
            {
                int amountGiven = 0;
                while (amountGiven < amount)
                {
                    itemObj = GlobalItemManager.Instance.CreateItem(generator);
                    if (!inventory.GiveItemServer(itemObj))
                    {
                        GlobalItemManager.SpawnWorldItem(itemObj, inventory);
                    }
                    amountGiven++;
                }
            }
#elif HURTWORLD
            PlayerSession   session   = target.Object as PlayerSession;
            PlayerInventory inventory = session.WorldPlayerEntity.GetComponent <PlayerInventory>();
            GlobalItemManager.Instance.GiveItem(session.Player, FindItem(itemNameOrId), amount);
#elif REIGNOFKINGS
            Player player = target.Object as Player;
            if (player == null)
            {
                return(false);
            }

            Container itemContainer = null;
            switch (container.ToLower())
            {
            case "belt":
                itemContainer = player.CurrentCharacter.Entity.GetContainerOfType(CollectionTypes.Hotbar);
                break;

            case "main":
                itemContainer = player.CurrentCharacter.Entity.GetContainerOfType(CollectionTypes.Inventory);
                break;
            }

            InvItemBlueprint blueprint = InvDefinitions.Instance.Blueprints.GetBlueprintForName(itemName, true, true);
            if (blueprint == null)
            {
                return(false);
            }

            ContainerManagement containerManagement = blueprint.TryGet <ContainerManagement>();
            int stackableAmount = containerManagement != null ? containerManagement.StackLimit : 0;
            int amountGiven     = 0;
            while (amountGiven < amount)
            {
                int amountToGive           = Mathf.Min(stackableAmount, amount - amountGiven);
                InvGameItemStack itemStack = new InvGameItemStack(blueprint, amountToGive, null);
                if (!ItemCollection.AutoMergeAdd(itemContainer.Contents, itemStack))
                {
                    int stackAmount = amountToGive - itemStack.StackAmount;
                    if (stackAmount != 0)
                    {
                        amountGiven += stackAmount;
                    }
                    else
                    {
                        break;
                    }
                }
                else
                {
                    amountGiven += amountToGive;
                }
                if (itemContainer.Contents.FreeSlotCount == 0)
                {
                    break;
                }
            }
#elif RUST
            Item item = ItemManager.Create(FindItem(itemNameOrId));
            if (item == null)
            {
                return(false);
            }

            item.amount = amount;

            BasePlayer basePlayer = target.Object as BasePlayer;
            if (basePlayer == null)
            {
                return(false);
            }

            ItemContainer itemContainer = null;
            switch (container.ToLower())
            {
            case "belt":
                itemContainer = basePlayer.inventory.containerBelt;
                break;

            case "main":
                itemContainer = basePlayer.inventory.containerMain;
                break;
            }

            if (!basePlayer.inventory.GiveItem(item, itemContainer))
            {
                item.Remove();
                return(false);
            }

            itemName = item.info.displayName.english;

            if (config.ShowPopupNotices)
            {
                target.Command("note.inv", item.info.itemid, amount);
                target.Command("gametip.showgametip", Lang("ItemReceived", target.Id, itemName, amount));
                timer.Once(2f, () => target.Command("gametip.hidegametip"));
            }
#endif
            if (config.ShowChatNotices)
            {
                Message(target, "ItemReceived", itemName, amount);
            }

            if (config.LogToConsole)
            {
                Log($"{target.Name} {amount} x {itemName}");
            }

            return(true);
        }