public bool Try_DropItem(SavableItem item, Slot parentSlot = null) { if (item && item.ItemData.WorldObject && !item.ItemData.IsBuildable) { var cameraTransform = GameController.WorldCamera.transform; GameObject droppedItem = Instantiate(item.ItemData.WorldObject, cameraTransform.position + cameraTransform.TransformVector(m_DropOffset), Random.rotation) as GameObject; var rigidbody = droppedItem.GetComponent <Rigidbody>(); if (rigidbody) { rigidbody.angularVelocity = Random.rotation.eulerAngles * m_DropAngularFactor; rigidbody.AddForce(cameraTransform.forward * m_DropSpeed, ForceMode.VelocityChange); Physics.IgnoreCollision(m_Player.GetComponent <Collider>(), droppedItem.GetComponent <Collider>()); } var pickup = droppedItem.GetComponent <ItemPickup>(); if (pickup) { pickup.ItemToAdd = item; } if (parentSlot) { parentSlot.ItemHolder.SetItem(null); } return(true); } return(false); }
/// <summary> /// /// </summary> private void On_ItemNotStackable(Slot slotUnderPointer, Slot initialSlot) { if (!initialSlot.AllowsItem(slotUnderPointer.CurrentItem)) { PutItemBack(initialSlot); return; } // Swap the items because they are of different kinds / not stackable / reached maximum stack size. SavableItem temp = slotUnderPointer.CurrentItem; if (!initialSlot.HasItem) { slotUnderPointer.ItemHolder.SetItem(m_DraggedItem); initialSlot.ItemHolder.SetItem(temp); } else { // Add as much as possible to the item's stack. int added; initialSlot.Parent.TryAddItem(m_DraggedItem.ItemData, m_DraggedItem.CurrentInStack, out added); // Add the remained items too. int remainedToAdd = m_DraggedItem.CurrentInStack - added; if (remainedToAdd > 0) { initialSlot.Parent.TryAddItem(m_DraggedItem.ItemData, remainedToAdd); } } }
private bool Try_ChangeEquippedItem(SavableItem item, bool instantly) { if (Player.EquippedItem.Get() == item) { return(true); } // Register the object for equipping. m_WaitingToEquip = true; m_NextTimeCanEquip = Time.time; if (!instantly && m_EquippedObject != null) { m_NextTimeCanEquip += m_HolsterTime; } // Register the current equipped object for disabling. if (m_EquippedObject != null) { m_EquippedObject.On_Holster(); m_WaitingToDisable = true; m_NextTimeCanDisable = Time.time; if (!instantly) { m_NextTimeCanDisable += m_HolsterTime; } } Player.EquippedItem.Set(item); return(true); }
/// <summary> /// /// </summary> public virtual void On_Draw(SavableItem correspondingItem) { IsEnabled = true; CorrespondingItem = correspondingItem; LastDrawTime = Time.time; m_Durability = correspondingItem.GetPropertyValue("Durability"); Draw.Send(); }
private void Awake() { var database = InventoryController.Instance.Database; ItemData itemData; if (database && database.FindItemByName(m_DefaultItem, out itemData)) { ItemToAdd = new SavableItem(itemData, m_DefaultAmount); } }
/// <summary> /// Removes the item if it exists in the inventory, if not, the method will return false. /// </summary> public bool TryRemoveItem(SavableItem item) { if (!enabled) { return(false); } for (int i = 0; i < m_AllCollections.Length; i++) { bool removed = m_AllCollections[i].TryRemoveItem(item); if (removed) { return(true); } } return(false); }
/// <summary> /// /// </summary> public void SetItem(SavableItem item) { if (CurrentItem) { CurrentItem.PropertyChanged.RemoveListener(On_PropertyChanged); CurrentItem.StackChanged.RemoveListener(On_StackChanged); } CurrentItem = item; if (CurrentItem) { CurrentItem.PropertyChanged.AddListener(On_PropertyChanged); CurrentItem.StackChanged.AddListener(On_StackChanged); } Updated.Send(this); }
/// <summary> /// /// </summary> private void On_Slot_BeginDrag(PointerEventData data, Slot slot, ItemContainer collection) { if (!slot.HasItem || InventoryController.Instance.IsClosed) { return; } m_Dragging = true; SavableItem itemUnderPointer = slot.CurrentItem; // Stack splitting. if (Input.GetKey(m_SplitKey) && itemUnderPointer.CurrentInStack > 1) { int initialAmount = itemUnderPointer.CurrentInStack; int half = initialAmount / 2; itemUnderPointer.CurrentInStack = initialAmount - half; m_DraggedItem = new SavableItem(itemUnderPointer.ItemData, half, itemUnderPointer.CurrentPropertyValues); slot.Refresh(); } else { slot.ItemHolder.SetItem(null); m_DraggedItem = itemUnderPointer; } m_DraggedItemRT = slot.GetDragTemplate(m_DraggedItem, m_DraggedItemAlpha); m_DraggedItemRT.SetParent(m_ParentCanvasRT, true); m_DraggedItemRT.localScale = Vector3.one * m_DraggedItemScale; Camera cam = data.pressEventCamera; Vector3 worldPoint; if (RectTransformUtility.ScreenPointToWorldPointInRectangle(m_ParentCanvasRT, (Vector3)data.position, cam, out worldPoint)) { m_DragOffset = slot.transform.position - worldPoint; } //Debug.Break(); }
public bool TryGenerate(out SavableItem runtimeItem) { runtimeItem = null; var database = InventoryController.Instance.Database; ItemData itemData; if (m_Random) { if (database.FindItemById(UnityEngine.Random.Range(0, database.GetItemCount() - 1), out itemData)) { runtimeItem = new SavableItem(itemData, (int)(itemData.StackSize * 0.1f) + 1); return(true); } } else if (database.FindItemByName(m_CustomName, out itemData)) { runtimeItem = new SavableItem(itemData, m_StackSize); return(true); } return(false); }
public override void On_Draw(SavableItem correspondingItem) { base.On_Draw(correspondingItem); //m_AmmoProperty = correspondingItem.GetPropertyValue("Ammo Type"); if (correspondingItem && correspondingItem.HasProperty("Ammo Type")) { m_AmmoProperty = correspondingItem.GetPropertyValue("Ammo Type"); } if (correspondingItem && correspondingItem.HasProperty("Ammo Capacity")) { m_AmmoProperty = correspondingItem.GetPropertyValue("Ammo Capacity"); } if (correspondingItem && correspondingItem.HasProperty("Ammo")) { m_AmmoProperty = correspondingItem.GetPropertyValue("Ammo"); } }
public bool TryAddItem(ItemData itemData, int amount, out int added, List <ItemProperty.Value> customPropertyValues = null) { added = 0; if (HasItem && itemData.Id != CurrentItem.Id) { return(false); } if (!HasItem) { CurrentItem = new SavableItem(itemData, 1, customPropertyValues); CurrentItem.CurrentInStack = 0; CurrentItem.PropertyChanged.AddListener(On_PropertyChanged); CurrentItem.StackChanged.AddListener(On_StackChanged); } int oldValue = CurrentItem.CurrentInStack; int surplus = amount + oldValue - itemData.StackSize; int currentInStack = oldValue; if (surplus <= 0) { currentInStack += amount; } else { currentInStack = itemData.StackSize; } CurrentItem.CurrentInStack = currentInStack; added = currentInStack - oldValue; Updated.Send(this); return(added > 0); }
//private ItemProperty.Value m_AmmoProperty; public override void On_Draw(SavableItem correspondingItem) { base.On_Draw(correspondingItem); //m_AmmoProperty = correspondingItem.GetPropertyValue("Ammo Type"); }
public override void On_Draw(SavableItem correspondingItem) { base.On_Draw(correspondingItem); StopAllCoroutines(); StartCoroutine(C_ToggleTorch(true)); }
/// <summary> /// /// </summary> private void On_Slot_EndDrag(PointerEventData data, Slot initialSlot, ItemContainer collection) { if (!m_Dragging) { return; } var slots = collection.Slots; GameObject objectUnderPointer = data.pointerCurrentRaycast.gameObject; Slot slotUnderPointer = null; if (objectUnderPointer) { slotUnderPointer = objectUnderPointer.GetComponent <Slot>(); } // Is there a slot under our pointer? if (slotUnderPointer) { // See if the slot allows this type of item. if (slotUnderPointer.AllowsItem(m_DraggedItem)) { // If the slot is empty... if (!slotUnderPointer.HasItem) { if (slotUnderPointer.ItemHolder) { slotUnderPointer.ItemHolder.SetItem(m_DraggedItem); } else { Debug.LogError("You tried to drop an item over a Slot which is not linked with any holder.", this); } } // If the slot is not empty... else { SavableItem itemUnderPointer = slotUnderPointer.CurrentItem; // Can we stack the items? bool canStackItems = (itemUnderPointer.Id == m_DraggedItem.Id && itemUnderPointer.ItemData.StackSize > 1 && itemUnderPointer.CurrentInStack < itemUnderPointer.ItemData.StackSize); if (canStackItems) { OnItemsAreStackable(slotUnderPointer, initialSlot); } else { On_ItemNotStackable(slotUnderPointer, initialSlot); } } } else { PutItemBack(initialSlot); } initialSlot.Refresh(); } // If the player didn't drop it on a slot... else { if (PlayerDroppedItem != null) { PlayerDroppedItem(collection, initialSlot, m_DraggedItem); } if (!InventoryController.Instance.Try_DropItem(m_DraggedItem)) { collection.TryAddItem(m_DraggedItem); } } Destroy(m_DraggedItemRT.gameObject); m_DraggedItem = null; m_Dragging = false; //initialSlot.interactable = initialSlot.HasItem; }
//reload Ammo public bool LoadAmmo(Slot initialSlot, SavableItem itemUnderPointer) { bool canLoadAmmo = ( //make sure that the item that you drag and the item in the slot are exixcte itemUnderPointer && m_DraggedItem && //make sure that both items have the property ammo type , so you dont get null values m_DraggedItem.HasProperty("Ammo Type") && itemUnderPointer.HasProperty("Ammo Type") && //make sure that the weapon and the ammo have the same Ammo type m_DraggedItem.GetPropertyValue("Ammo Type").String == itemUnderPointer.GetPropertyValue("Ammo Type").String&& //make sure that only the drager item is an Ammo and not the item already in the slot m_DraggedItem.HasProperty("Is Ammo") && m_DraggedItem.GetPropertyValue("Is Ammo").Bool&& !itemUnderPointer.HasProperty("Is Ammo") && itemUnderPointer.HasProperty("Ammo Capacity") && itemUnderPointer.HasProperty("Ammo ")); if (canLoadAmmo) { //define out variables //pick up amm stock size int ammostack = m_DraggedItem.CurrentInStack; //current ammo m_AmmoAmount = itemUnderPointer.GetPropertyValue("Ammo"); var ammo = m_AmmoAmount.Int; //capacity m_AmmoCapacity = itemUnderPointer.GetPropertyValue("Ammo Capacity"); //make sure taht the gun is not already full loaded if (m_AmmoAmount.Int.Current < m_AmmoCapacity.Int.Current) { //check if there ammo in object we pick up if (ammostack > 0) { int needAmmo = m_AmmoCapacity.Int.Current - m_AmmoAmount.Int.Current; //if you need more mmothan what is the enter stack we consule all the ammo if (needAmmo >= ammostack) { //reload the gun ammo.Current += ammostack;//has to be correct type m_AmmoAmount.SetValue(ItemProperty.Type.Int, ammo); GameController.LocalPlayer.Reload.Try(needAmmo); //destroy Ammo Destroy(m_DraggedItemRT.gameObject); m_DraggedItem = null; m_Dragging = false; initialSlot.Refresh(); return(true); } //else we will use all the ammo we can and return what is left else { ammo.Current += needAmmo;//has to correct type m_AmmoAmount.SetValue(ItemProperty.Type.Int, ammo); int remainingAmmo = ammostack - needAmmo; m_DraggedItem.CurrentInStack = remainingAmmo; GameController.LocalPlayer.Reload.Try(needAmmo); //put what it left in our ammo stack where we pick it up PutItemBack(initialSlot); initialSlot.Refresh(); //destroy the ammo(because we already put it back) Destroy(m_DraggedItemRT.gameObject); m_DraggedItem = null; m_Dragging = false; return(true); } } else { return(false); } } else { //Gun is full /put the bullet back PutItemBack(initialSlot); initialSlot.Refresh(); //destroy the ammo(because we already put it back) Destroy(m_DraggedItemRT.gameObject); m_DraggedItem = null; m_Dragging = false; return(true); } } else { return(false); } }