public virtual void SetItem(Slottable newItem) { item = newItem; icon.enabled = true; icon.sprite = item.icon; }
public void AddItemToData(Slottable slottable, int quantity) { InventoryItem item = slottable.m_Item; bool found = false; for (int i = 0; i < inventory.entries.Count; i++) { if (item.isStackable) { if (inventory.entries[i].itemInstance.m_item.itemId == item.itemId) { inventory.entries[i].quantity += quantity; found = true; } } else { if (inventory.entries[i].itemInstance == slottable.m_itemInstance) { inventory.entries[i].quantity += quantity; found = true; } } } if (!found) { InventoryItemEntry newEntry = new InventoryItemEntry(); newEntry.itemInstance = slottable.m_itemInstance; newEntry.quantity = quantity; inventory.entries.Add(newEntry); } }
public virtual void ClearItem() { item = null; icon.enabled = false; icon.sprite = null; }
public bool CheckAllSlottablesForCursorHover(PointerEventData eventData, ref Slottable sbUnderCursor) { Slottable prevSlottable = sbUnderCursor; sbUnderCursor = null; for (int i = 0; i < SlotCount; i++) { if (this[i].slottable != null) { if (this[i].slottable.m_isActiveForSelection) { if (this[i].slottable.gameObject == eventData.pointerEnter || this[i].slottable.ChildIsPointerEnter(eventData)) { sbUnderCursor = this[i].slottable; return(true); } } } } if (prevSlottable != null) { prevSlottable.SetHoverState(false); } return(false); }
public void GetSGandSlottableUnderCursor(ref Slottable sbUnderCursor, ref SlotGroup sgUnderCursor, PointerEventData eventData) { // sgUnderCursor = null; // sbUnderCursor = null; if (sgUnderCursor != null && !RectTransformUtility.RectangleContainsScreenPoint(sgUnderCursor.m_dropZoneRect, eventData.position)) { sgUnderCursor.SetHoverState(false); sgUnderCursor = null; m_sgUnderCursor = null; } // if(sbUnderCursor != null && !RectTransformUtility.RectangleContainsScreenPoint(sbUnderCursor.m_rectTrans, eventData.position)){ // sbUnderCursor = null; // sbUnderCursor // m_sgUnderCursor = null; // } for (int i = 0; i < m_slotGroups.Count; i++) { if (m_slotGroups[i].m_isActiveForSelection) { if (RectTransformUtility.RectangleContainsScreenPoint(m_slotGroups[i].m_dropZoneRect, eventData.position)) { if (sgUnderCursor == m_slotGroups[i] /*&& sgUnderCursor != null*/) { //do nothing } else { if (sgUnderCursor != null) { sgUnderCursor.SetHoverState(false); } m_slotGroups[i].SetHoverState(true); sgUnderCursor = m_slotGroups[i]; m_sgUnderCursor = sgUnderCursor; } } Slottable prevSlottableUnderCursor = sbUnderCursor; if (m_slotGroups[i].CheckAllSlottablesForCursorHover(eventData, ref sbUnderCursor)) { if (sbUnderCursor == prevSlottableUnderCursor) { //do nothing } else { if (prevSlottableUnderCursor != null) { prevSlottableUnderCursor.SetHoverState(false); } sbUnderCursor.SetHoverState(true); m_sbUnderCursor = sbUnderCursor; } return; } } } }
void Swap(Slottable targetSlottable) { SlotGroup targetSG = targetSlottable.m_OrigSG; targetSG.RemoveItemFromData(targetSlottable, targetSlottable.m_Quantity); this.m_OrigSG.RemoveItemFromData(this, this.m_PickAmount); targetSG.AddItemToData(this, this.m_PickAmount); this.m_OrigSG.AddItemToData(targetSlottable, targetSlottable.m_Quantity); }
public void RemoveItemFromData(Slottable slottable, int quantity) { for (int i = 0; i < inventory.entries.Count; i++) { if (inventory.entries[i].itemInstance == slottable.m_itemInstance) { inventory.entries[i].quantity -= quantity; } } }
void FilterPoolSGSlottables(Slottable slottable) { for (int i = 0; i < m_slotGroups.Count; i++) { if (m_slotGroups[i].m_slotGroupType == SlotGroupType.Pool) { m_slotGroups[i].FilterSlottables(slottable); } } }
public void OnPointerEnter(PointerEventData eventData) { print(this.name + "'s PointerEnter called"); if (eventData.pointerDrag != null && eventData.pointerDrag.GetComponent <Slottable>() != null) { Slottable travellingSlottable = eventData.pointerDrag.GetComponent <Slottable>(); travellingSlottable.m_isOnSlot = true; travellingSlottable.m_hoverSlot = this; DebugUtility.PrintRed("is on slot: " + travellingSlottable.m_isOnSlot + ", hoverSlot: " + travellingSlottable.m_hoverSlot.gameObject.name); } }
public void OnDrop(PointerEventData eventData) { Slottable draggedSlottable = eventData.pointerDrag.GetComponent <Slottable>(); if (draggedSlottable != null && draggedSlottable.m_isPickedUp) { InventoryItem droppedItem = draggedSlottable.m_Item; StartCoroutine(draggedSlottable.MoveToSlot(this)); Debug.Log(droppedItem.itemName.ToString() + " is dropped on " + this.name); } }
public void SlotIn(Slottable sltbl) { DebugUtility.PrintRed("Slot in called"); newSlottable = (Slottable)GameObject.Instantiate(slottablePrefab, Vector3.zero, Quaternion.identity, slotZoneTrans); newSlottable.transform.SetAsLastSibling(); newSlottable.Initialize(null, sltbl.m_itemInstance, sltbl.m_Item, sltbl.m_PickAmount); RectTransform newRT = newSlottable.GetComponent <RectTransform>(); newRT.anchorMin = new Vector2(0f, 1f); newRT.anchorMax = new Vector2(0f, 1f); newRT.anchoredPosition = new Vector2(.5f, .5f); newRT.sizeDelta = new Vector2(80f, 80f); }
public RectTransform GetSlotRect(Slottable slottable) { RectTransform result = null; for (int i = 0; i < SlotCount; i++) { if (this[i].slottable != null) { if (this[i].slottable.m_itemInstance == slottable.m_itemInstance) { result = this[i].slotRect; } } } return(result); }
public RectTransform GetNewSlotRect(Slottable slottable) { RectTransform result = null; for (int i = 0; i < m_tempSlots.Count; i++) { if (m_tempSlots[i].slottable != null) { if (m_tempSlots[i].slottable.m_itemInstance == slottable.m_itemInstance) { result = m_tempSlots[i].slotRect; } } } return(result); }
public void FilterDestination(Slottable slottable) { SetActiveStateAll(false); InventoryItem invItem = slottable.m_Item; if (invItem is Bow) { ActivateSlotGroup(SlotGroupType.Bow); } else if (invItem is Wear) { ActivateSlotGroup(SlotGroupType.Wear); } else if (invItem is CarriedGear) { ActivateSlotGroup(SlotGroupType.CarriedGear); } slottable.m_OrigSG.SetActiveForSelectionState(true); ActivateSlotGroup(SlotGroupType.Pool); FilterPoolSGSlottables(slottable); }
public void OnPointerExit(PointerEventData eventData) { print(this.name + "'s PointerExit called"); if (eventData.pointerDrag != null && eventData.pointerDrag.GetComponent <Slottable>() != null) { Slottable travellingSlottable = eventData.pointerDrag.GetComponent <Slottable>(); travellingSlottable.m_isOnSlot = false; // travellingSlottable.m_hoverSlot = null; string str; if (travellingSlottable.m_hoverSlot == null) { str = "null"; } else { str = travellingSlottable.m_hoverSlot.gameObject.name; } DebugUtility.PrintRed("is on slot: " + travellingSlottable.m_isOnSlot + ", hoverSlot: " + str); } }
public void FilterSlottables(Slottable slottable) { InventoryItem invItem = slottable.m_Item; for (int i = 0; i < SlotCount; i++) { if (this[i].slottable != null) { this[i].slottable.SetActiveForSelectionState(false); if (invItem is Bow) { if (this[i].slottable.m_Item is Bow) { this[i].slottable.SetActiveForSelectionState(true); } } else if (invItem is Wear) { if (this[i].slottable.m_Item is Wear) { this[i].slottable.SetActiveForSelectionState(true); } } else if (invItem is CarriedGear) { if (this[i].slottable.m_Item is CarriedGear) { this[i].slottable.SetActiveForSelectionState(true); } } else if (invItem is CraftItem) { if (this[i].slottable.m_Item is CraftItem) { this[i].slottable.SetActiveForSelectionState(true); } } } } }
public void OnDrop(PointerEventData eventData) { InventorySlot drop = eventData.pointerDrag.GetComponent <InventorySlot>(); if (drop.IsEmptySlot()) { return; } Debug.Log(drop + " was dropped onto " + this.name); Slottable droppedItem = drop.item; if (this.IsEmptySlot()) { drop.ClearItem(); } else { drop.SetItem(this.item); } this.SetItem(droppedItem); }
void Transact(PointerEventData eventData) { StopPickUpTimer(); if (m_isPickedUp) { SlotGroup targetSG = null; bool swapped = false; bool added = false; Slottable swappedSlottable = null; if (m_slottableUnderCursor != null) // on some slottable { if (m_slottableUnderCursor != this) // the sb is not the orig { m_slottableUnderCursor.OnNonEventDrop(eventData); targetSG = m_SGUnderCursor; if (targetSG != null && targetSG != m_OrigSG) //it's in some other SG { if (this.m_Item.isStackable) { // if(targetSG.GetSlotIndex(this.m_Item.itemId) != -1){ if (m_slottableUnderCursor.m_Item.itemId == this.m_Item.itemId) { /* this is stackable and SBUC is same item */ if (m_OrigSG.isSubtractable) { Add(targetSG); added = true; } } else { /* this is stackable but SBUC has different item */ Swap(m_slottableUnderCursor); swapped = true; swappedSlottable = m_slottableUnderCursor; } } else { /* this is not stackable */ if (m_slottableUnderCursor.m_itemInstance != this.m_itemInstance) { Swap(m_slottableUnderCursor); swapped = true; swappedSlottable = m_slottableUnderCursor; } else { if (m_OrigSG.isSubtractable) { Add(targetSG); added = true; } } } } else //targetSG == null || targetSG == m_OrigSG { StartCoroutine(Revert(eventData)); return; } } else //m_slottableUnderCursor == this { OnNonEventDrop(eventData); m_isTouchedInside = false; m_isTouchedOutside = false; StartCoroutine(WaitAndReset(eventData)); return; } } else //slottableUnderCursor == null { if (m_SGUnderCursor != null) { if (m_SGUnderCursor != m_OrigSG) // in some other SG { targetSG = m_SGUnderCursor; if (m_SGUnderCursor.SlotCount == 1) { if (m_SGUnderCursor[0].slottable != null) { if (m_SGUnderCursor[0].slottable.m_Item.itemId == this.m_Item.itemId && this.m_Item.isStackable) { /* this is stackable and the only Slottable the SG has has the same item */ if (m_OrigSG.isSubtractable) { Add(m_SGUnderCursor); added = true; } } else { /* this is not stackable, nor the only slottable has different item */ Swap(m_SGUnderCursor[0].slottable); swapped = true; swappedSlottable = m_SGUnderCursor[0].slottable; } } else { /* the only slot doesn't have a slottable so fill it */ if (m_OrigSG.isSubtractable) { Add(m_SGUnderCursor); added = true; } } } else //more than one slot { if (m_SGUnderCursor.HasVacancy) { //filled if (m_OrigSG.isSubtractable) { Add(m_SGUnderCursor); added = true; } } else //no vacancy { if (m_SGUnderCursor.isExpandable) { if (m_OrigSG.isSubtractable) { Add(m_SGUnderCursor); added = true; } } else if (m_SGUnderCursor.GetSlotIndex(m_Item.itemId) != -1) //the SG has same item { if (this.m_Item.isStackable) { /* same and stackable */ if (m_OrigSG.isSubtractable) { Add(m_SGUnderCursor); added = true; } } // else{ // /* this is not stackable // */ // StartCoroutine(Revert(eventData)); // return; // } } // else{ // /* no same item in the sg // */ // StartCoroutine(Revert(eventData)); // return; // } } } } else //SGUC is the orig SG, and there's no SBUC { StartCoroutine(Revert(eventData)); return; } } else //there's no SGUC nor SBUC { StartCoroutine(Revert(eventData)); return; } } if (!added && !swapped) { StartCoroutine(Revert(eventData)); } else { targetSG.CleanUpData(); this.m_OrigSG.CleanUpData(); targetSG.SortData(); this.m_OrigSG.SortData(); targetSG.UpdateSlots(eventData); this.m_OrigSG.UpdateSlots(eventData); this.StartCoroutine(this.MoveToSlot(targetSG, targetSG.GetNewSlotRect(this), eventData)); if (swapped) { swappedSlottable.m_draggedIcon = swappedSlottable.CreateAndSetupDraggedIcon(m_canvas, ref swappedSlottable.m_pickedQuantText); swappedSlottable.m_draggedIcon.GetComponent <RectTransform>().anchoredPosition = ConvertRectPosToCanvasPos(swappedSlottable.m_OrigSG.GetSlotRect(swappedSlottable), eventData); swappedSlottable.StartCoroutine(swappedSlottable.MoveToSlot(this.m_OrigSG, this.m_OrigSG.GetNewSlotRect(swappedSlottable), eventData)); } } } else { m_isTouchedInside = false; m_isTouchedOutside = false; StartCoroutine(WaitAndReset(eventData)); } }
public void UpdateSlots(PointerEventData eventData) { /* create new slots part * search in the current slots for slottable reference * update quantit * if not found * create new and update its position and hierarchy * disable its image component * if the quantity is 0 and not pool * do not include it in the new slots * * Transit part * for each slottable in the current slots * try to spot the new slot referring to the newSlots * if found, start to move toward it * if not, detach it and disable image and leave it there until it is deleted upon completion of transaction */ /* Create part */ m_tempSlots = new List <Slot>(); for (int i = 0; i < m_slots.Count; i++) { Slot newSlot = new Slot(); newSlot.slottable = null; newSlot.slotRect = m_slots[i].slotRect; m_tempSlots.Add(newSlot); } int addedSlotsCount = inventory.entries.Count - m_slots.Count; if (addedSlotsCount > 0) { for (int i = 0; i < addedSlotsCount; i++) { Slot newSlot = new Slot(); newSlot.slottable = null; newSlot.slotRect = Instantiate(m_slotPrefab, Vector3.zero, Quaternion.identity).GetComponent <RectTransform>(); newSlot.slotRect.SetParent(panel); newSlot.slotRect.SetAsLastSibling(); // LayoutGroup panelLayoutGroup = panel.GetComponent<LayoutGroup>(); // if(panelLayoutGroup != null){ // panelLayoutGroup.CalculateLayoutInputHorizontal(); // panelLayoutGroup.CalculateLayoutInputVertical(); // panelLayoutGroup.SetLayoutHorizontal(); // panelLayoutGroup.SetLayoutVertical(); // } m_tempSlots.Add(newSlot); } } /* at this point the m_tempSlots has at least as many slots with slotRect as inventory entries * slotRects are oredered hierarchically * slottables are empty */ for (int i = 0; i < inventory.entries.Count; i++) { bool found = false; for (int j = 0; j < m_slots.Count; j++) { if (m_slots[j].slottable != null) { if (m_slots[j].slottable.m_itemInstance == inventory.entries[i].itemInstance) { found = true; m_tempSlots[i].slottable = m_slots[j].slottable; m_tempSlots[i].slottable.m_Quantity = inventory.entries[i].quantity; } } } if (!found) { Slottable newSlottable = Instantiate(slottablePrefab, Vector3.zero, Quaternion.identity); newSlottable.Initialize(this, inventory.entries[i].itemInstance, inventory.entries[i].itemInstance.m_item, inventory.entries[i].quantity); newSlottable.Attach(m_tempSlots[i].slotRect); newSlottable.InitHierarchyDependents(); newSlottable.GetComponent <Image>().enabled = false; m_tempSlots[i].slottable = newSlottable; } if (m_tempSlots[i].slottable.m_Quantity == 0 && m_slotGroupType != SlotGroupType.Pool) { m_tempSlots[i].slottable = null; } } for (int i = 0; i < m_tempSlots.Count; i++) { if (m_tempSlots[i].slottable == null && isExpandable) { m_tempSlots.RemoveAt(i); } } /* at this point all the itemInstance in the inventory is represented as slottable and stored in m_tempSlots * if not pool the zero quantity slottables are omitted */ /* Transit part */ for (int i = 0; i < m_slots.Count; i++) { bool found = false; for (int j = 0; j < m_tempSlots.Count; j++) { if (m_slots[i].slottable != null && m_tempSlots[j].slottable != null) { if (m_slots[i].slottable == m_tempSlots[j].slottable) { found = true; m_slots[i].slottable.StartCoroutine(m_slots[i].slottable.MoveWithinSG(m_tempSlots[j].slotRect, .5f, eventData)); continue; } } } if (!found) { if (m_slots[i].slottable != null) { m_slots[i].slottable.Detach(eventData); m_slots[i].slottable.GetComponent <Image>().enabled = false; } } } }
public void InitSlots() { /* if isExpandable as many newSlotRects as needed needs to be created to accomodate slottables. * populate the list with pairs of newly created slottables and slotRects * children all the slottables to slotRects */ /* create slottables * initialize and stuck them in a temp list * sort in the order of itemId */ List <Slottable> slottableTempList = new List <Slottable>(); for (int i = 0; i < inventory.entries.Count; i++) { // if(inventory.entries[i].itemInstance != null){ if ((m_slotGroupType != SlotGroupType.Pool && inventory.entries[i].quantity > 0) || m_slotGroupType == SlotGroupType.Pool) { Slottable newSlottable = (Slottable)Instantiate(slottablePrefab, Vector3.zero, Quaternion.identity); newSlottable.Initialize(this, inventory.entries[i].itemInstance, inventory.entries[i].itemInstance.m_item, inventory.entries[i].quantity); slottableTempList.Add(newSlottable); } // } } List <Slottable> orderedTemp = new List <Slottable>(); while (slottableTempList.Count > 0) { int prevId = -1; int idAtMin = -1; for (int i = 0; i < slottableTempList.Count; i++) { if (slottableTempList[i].m_Item.itemId < prevId || prevId == -1) { prevId = slottableTempList[i].m_Item.itemId; idAtMin = i; } } orderedTemp.Add(slottableTempList[idAtMin]); slottableTempList.RemoveAt(idAtMin); } /* populate a temp list of slotRect in the sibling order * create if isExpandable * start with a clean slate in that case */ List <RectTransform> slotRTTempList = new List <RectTransform>(); if (isExpandable) { int numOfSlotsToCreate = inventory.entries.Count; if (panel.childCount != 0) { for (int i = 0; i < panel.childCount; i++) { Destroy(panel.GetChild(i)); } } /* create slots and add them in the temp list */ for (int i = 0; i < numOfSlotsToCreate; i++) { RectTransform newSlotRect = Instantiate(m_slotPrefab, Vector3.zero, Quaternion.identity, panel).GetComponent <RectTransform>(); slotRTTempList.Add(newSlotRect); } } else { for (int i = 0; i < panel.childCount; i++) { RectTransform slotRect = panel.GetChild(i).GetComponent <RectTransform>(); slotRTTempList.Add(slotRect); } } /* make pairs of slottable and slotRect from two temp lists, * and populate m_slots list * do keep in mind that there is possibly empty slots (one without matching slottables) */ if (m_slots != null) { m_slots.Clear(); } else { m_slots = new List <Slot>(); } for (int i = 0; i < slotRTTempList.Count; i++) { Slot newSlot = new Slot(); if (/*orderedTemp[i] == null*/ i >= orderedTemp.Count) { newSlot.slottable = null; } else { newSlot.slottable = orderedTemp[i]; } newSlot.slotRect = slotRTTempList[i]; // newSlot.slottable.m_rectTrans.anchoredPosition = newSlot.slotRect.anchoredPosition; // newSlot.slottable.transform.SetParent(newSlot.slotRect); if (newSlot.slottable != null) { newSlot.slottable.Attach(newSlot.slotRect); newSlot.slottable.InitHierarchyDependents(); newSlot.slottable.CheckQuantityColor(); } m_slots.Add(newSlot); } }
public override void SetItem(Slottable newItem) { base.SetItem(newItem); button.interactable = true; }
public override void SetItem(Slottable newItem) { base.SetItem(newItem); itemText.text = newItem.itemName; }