Esempio n. 1
0
        private RustItem?CreateItem(string itemId, IItemState?state)
        {
            if (!int.TryParse(itemId, out var parsedItemId))
            {
                throw new ArgumentException($"Invalid Item ID: {itemId}", nameof(itemId));
            }

            var item = ItemManager.CreateByItemID(parsedItemId);

            if (item == null)
            {
                return(null);
            }

            var rustItem = new RustItem(item);

            if (state != null && !(state is NullItemState))
            {
                rustItem.SetItemAmountAsync(state.ItemAmount);
                rustItem.SetItemQualityAsync(state.ItemQuality);
                rustItem.Item.maxCondition = (float)state.ItemDurability;
            }

            return(rustItem);
        }
Esempio n. 2
0
        private async UniTask <RustItem?> CreateItem(string itemId, IItemState?state)
        {
            if (!int.TryParse(itemId, out var parsedItemId))
            {
                throw new ArgumentException($"Invalid Item ID: {itemId}", nameof(itemId));
            }

            await UniTask.SwitchToMainThread();

            var item = ItemManager.CreateByItemID(parsedItemId);

            if (item == null)
            {
                return(null);
            }

            var rustItem = new RustItem(item);

            if (state != null && !(state is NullItemState))
            {
                await rustItem.SetItemAmountAsync(state.ItemAmount);

                await rustItem.SetItemQualityAsync(state.ItemQuality);

                await rustItem.SetItemDurabilityAsync(state.ItemDurability);
            }

            return(rustItem);
        }
Esempio n. 3
0
        public Task <IItemDrop> SpawnItemAsync(Vector3 position, string itemId, IItemState state = null)
        {
            ValidateState(state);

            async UniTask <IItemDrop> SpawnItemTask()
            {
                await UniTask.SwitchToMainThread();

                RustItem item = CreateItem(itemId, state);

                var droppedItem = item.Item
                                  .Drop(position.ToUnityVector(), UnityVector3.zero, UnityQuaternion.identity) as DroppedItem;

                return(droppedItem == null ? null : new RustItemDrop(droppedItem));
            }

            return(SpawnItemTask().AsTask());
        }
Esempio n. 4
0
        public Task <IInventoryItem> GiveItemAsync(IInventory inventory, string itemId, IItemState state = null)
        {
            ValidateState(state);

            async UniTask <IInventoryItem> GiveItemTask()
            {
                await UniTask.SwitchToMainThread();

                if (inventory is RustPlayerInventory playerInventory)
                {
                    RustItem item = CreateItem(itemId, state);

                    playerInventory.GiveItem(item.Item);
                    return(new RustInventoryItem(item));
                }

                throw new NotSupportedException($"Inventory type not supported: {inventory.GetType().FullName}");
            }

            return(GiveItemTask().AsTask());
        }
Esempio n. 5
0
 public RustItemDrop(DroppedItem droppedItem)
 {
     Item        = new RustItem(droppedItem.item);
     DroppedItem = droppedItem;
     Transform   = new RustNetworkableTransform(droppedItem);
 }
Esempio n. 6
0
 public RustInventoryItem(RustItem item)
 {
     Item = item;
 }