private void Refresh()
{
// This will work for now lol.
foreach (KeyValuePair <string, InventoryItemSlot> lEntry in slots)
{
Destroy(lEntry.Value.gameObject);
}
slots.Clear();
// Add inventory slots to a sorted list.
for (int i = 0; i < ParentInventory.Count; i++)
{
InventoryItemSlot lNewSlot = Instantiate(slotPrefab);
lNewSlot.transform.SetParent(content.transform, false);
lNewSlot.Initialize(ParentInventory.GetItem(i));
slots.Add(lNewSlot.Item.Item.ItemName, lNewSlot);
}
// Sort the items in the hierarchy to be identical with the sorted list
for (int i = 0; i < slots.Count; i++)
{
slots.Values[i].transform.SetSiblingIndex(i);
}
}
public void insertItemInSlot(Item i, Vector2 slot)
{
if (!canInsertItemInSlot(i, slot))
{
return;
}
int ind = getIndexForSlot(slot);
InventoryItemSlot sl = inventory[ind];
sl.item = i;
sl.itemSlot = sl;
foreach (Vector2 itemSlot in i.getShape())
{
Vector2 actualSlot = slot + itemSlot;
int index = getIndexForSlot(actualSlot);
InventoryItemSlot invenSlot = inventory[index];
if (itemSlot.x == 0 && itemSlot.y == 0)
{
continue;
}
else
{
sl.addOtherSlot(invenSlot);
invenSlot.itemSlot = sl;
}
}
}
public int AddItem(BaseItem item, int count)
{
int left = count;
var slot = findItemSlot(item);
if (slot == null)
{
if (!IsFull)
{
slot = new InventoryItemSlot(item.ItemType, item.ItemID, count);
m_ItemSlots.Add(slot);
left = 0;
}
}
else
{
int sum = slot.Count + count;
if (sum > item.MaxCount)
{
left = sum - item.MaxCount;
}
slot.Count += (count - left);
}
return(left);
}
public Inventory()
{
purse = new Purse();
inventory = new InventoryItemSlot[16];
for (int n = 0; n < 16; n++)
{
inventory[n] = new InventoryItemSlot(n);
// inventory[n].itemSlot = inventory[n];
// inventory[n].item = new Turret(new TestFrame(), new TestApplicator(), new TestGear(), new TestEnergySource());
}
/* inventory[0].itemSlot = inventory[0];
* inventory[0].item = new Turret(new TestFrame(), new TestApplicator(), new TestGear(), new TestEnergySource());
* inventory[1].itemSlot = inventory[0];
* inventory[4].itemSlot = inventory[0];
* inventory[5].itemSlot = inventory[0];
* inventory[2].itemSlot = inventory[2];
* inventory[3].itemSlot = inventory[2];
* inventory[6].itemSlot = inventory[2];
* inventory[7].itemSlot = inventory[2];
* inventory[2].item = new Trap(new TestFrame(), new TestApplicator(), new TestGear(), new TestTrigger());
* for (int n=0;n<5;n++) {
* inventory[2].item.addToStack(new Trap(new TestFrame(), new TestApplicator(), new TestGear(), new TestTrigger()));
* }
* inventory[0].addOtherSlot(inventory[1]);
* inventory[0].addOtherSlot(inventory[4]);
* inventory[0].addOtherSlot(inventory[5]);
* inventory[2].addOtherSlot(inventory[3]);
* inventory[2].addOtherSlot(inventory[6]);
* inventory[2].addOtherSlot(inventory[7]);*/
}
private void Inventory_OnItemListRemoved(object sender, Item itemRemoved)
{
InventoryItemSlot inventoryItemSlot = GetItemTypeAlreadyInInventory(itemRemoved.itemType);
RectTransform itemSlotRectTransform;
if (inventoryItemSlot != null)
{
inventoryItemSlot.SetAmount(inventoryItemSlot.GetAmount() - itemRemoved.amount);
itemSlotRectTransform = inventoryItemSlot.GetComponent <RectTransform>();
Transform amountTransform = itemSlotRectTransform.Find("Amount");
TextMeshProUGUI uiText = amountTransform.Find("Text").GetComponent <TextMeshProUGUI>();
if (inventoryItemSlot.GetAmount() == 0)
{
Destroy(inventoryItemSlot.gameObject);
}
else if (inventoryItemSlot.GetAmount() > 1)
{
uiText.SetText(inventoryItemSlot.GetAmount().ToString());
amountTransform.gameObject.SetActive(true);
}
else
{
amountTransform.gameObject.SetActive(false);
}
}
}
private void Inventory_OnItemListAdded(object sender, Item itemAdded)
{
InventoryItemSlot inventoryItemSlot = GetItemTypeAlreadyInInventory(itemAdded.itemType);
RectTransform itemSlotRectTransform;
if (inventoryItemSlot != null)
{
itemSlotRectTransform = inventoryItemSlot.GetComponent <RectTransform>();
Transform amountTransform = itemSlotRectTransform.Find("Amount");
TextMeshProUGUI uiText = amountTransform.Find("Text").GetComponent <TextMeshProUGUI>();
inventoryItemSlot.SetAmount(inventoryItemSlot.GetAmount() + itemAdded.amount);
uiText.SetText(inventoryItemSlot.GetAmount().ToString());
if (inventoryItemSlot.GetAmount() > 1)
{
amountTransform.gameObject.SetActive(true);
}
else
{
amountTransform.gameObject.SetActive(false);
}
}
else
{
itemSlotRectTransform = Instantiate(_itemSlotTemplate, _itemSlotContainer).GetComponent <RectTransform>();
itemSlotRectTransform.gameObject.SetActive(true);
itemSlotRectTransform.GetComponent <Button>().onClick.AddListener(() => {
// Use item
_inventory.UseItem(itemAdded);
});
itemSlotRectTransform.GetComponent <InventoryItemSlot>().SetItemType(itemAdded.itemType);
itemSlotRectTransform.GetComponent <InventoryItemSlot>().SetAmount(itemAdded.amount);
Image imagem = itemSlotRectTransform.Find("Image").GetComponent <Image>();
imagem.sprite = itemAdded.GetInventorySprite();
Transform amountTransform = itemSlotRectTransform.Find("Amount");
if (itemAdded.amount > 1)
{
TextMeshProUGUI uiText = amountTransform.Find("Text").GetComponent <TextMeshProUGUI>();
uiText.SetText(itemAdded.amount.ToString());
}
else
{
amountTransform.gameObject.SetActive(false);
}
}
}
/// <summary>
/// Use this to restore a slot from save
/// </summary>
/// <param name="itemReference"></param>
/// <param name="maxCount"></param>
public void RestoreSlot(InventoryItemSlot slot, bool reDrawInventory = true, bool addSlot = false)
{
bool addedSlot = false;
for (int i = 0; i < inventory.Count; i++)
{
if (inventory[i].count == 0)
{
if (slot.mySlotType != InventoryItemSlot.SlotType.storage)
{
if (inventory[i].mySlotType == slot.mySlotType && inventory[i].myItem == slot.myItem)
{
inventory[i].count = slot.count;
addedSlot = true;
break;
}
}
else
{
if (inventory[i].mySlotType == InventoryItemSlot.SlotType.storage)
{
inventory[i].myItem = slot.myItem;
inventory[i].count = slot.count;
addedSlot = true;
break;
}
}
}
}
if (addSlot)
{
if (!addedSlot)
{
inventory.Add(slot);
}
}
if (reDrawInventory)
{
drawInventoryEvent?.Invoke();
InventoryContentsChanged();
}
}
public ItemReturn removeItemFromSlot(Vector2 slot)
{
InventoryItemSlot sl = inventory[getIndexForSlot(slot)];
InventoryItemSlot actualSlot = sl.itemSlot;
if (actualSlot == null)
{
return(new ItemReturn());
}
Vector2 actualSlotVec = getSlotForIndex(actualSlot.index);
Item i = actualSlot.getItem();
foreach (InventoryItemSlot slots in actualSlot.otherSlots)
{
slots.removeItem();
}
actualSlot.removeItem();
return(new ItemReturn(i, slot - actualSlotVec));
}
public void SetUp(InventoryItemSlot _myDat, IInventoryController _myCont, bool _updateColor)
{
myDat = _myDat;
myCont = _myCont;
updateColor = _updateColor;
UpdateAmount();
myCont.inventoryContentsChangedEvent += UpdateAmount;
if (updateColor)
{
switch (myDat.mySlotType)
{
case InventoryItemSlot.SlotType.output:
bg.color = outputColor;
break;
case InventoryItemSlot.SlotType.input:
bg.color = inputColor;
break;
case InventoryItemSlot.SlotType.storage:
bg.color = storageColor;
break;
case InventoryItemSlot.SlotType.house:
bg.color = houseColor;
break;
case InventoryItemSlot.SlotType.worker:
bg.color = workerColor;
break;
}
}
}
public InventoryData(InventoryItemSlot slot)
{
if (!slot.myItem.isEmpty())
{
uniqueName = slot.myItem.uniqueName;
}
else
{
uniqueName = "";
}
count = slot.count;
maxCount = slot.maxCount;
switch (slot.mySlotType)
{
case InventoryItemSlot.SlotType.input:
type = 0;
break;
case InventoryItemSlot.SlotType.output:
type = 1;
break;
case InventoryItemSlot.SlotType.storage:
type = 2;
break;
case InventoryItemSlot.SlotType.house:
type = 3;
break;
case InventoryItemSlot.SlotType.worker:
type = 4;
break;
default:
Debug.LogError("Unknown item slot type detected!");
type = -1;
break;
}
}
void Start()
{
for (int i = 0; i < inventorySize; i++)
{
InventoryItemSlot itemSlot = GameObject.Instantiate(ItemSlotPrefab);
itemSlot.transform.SetParent(container.transform);
slots.Add(itemSlot);
}
foreach (ItemInventory i in inventory)
{
Item item = itemDatabase.itemList[i.item.id - 1];
if (i.inventory_position < slots.Count && slots [i.inventory_position].getItem() == null)
{
slots [i.inventory_position].SetItem(item);
}
else
{
GetEmptySlot().SetItem(item);
}
}
}
public void mouseHoverEnter(Image overlayObject)
{
Color c = goodColor;
// c.a = 103.0f/255.0f;
InventorySlot slot = overlayObject.GetComponent <InventoryItem>().slot;
Debug.Log(slot);
List <Image> otherImages = new List <Image>();
if (selectedItem == null)
{
if (UnitGUI.inventorySlots.Contains(slot))
{
Debug.Log(slot);
InventoryItemSlot iis = (selectedCharacter == null ? null : selectedCharacter.characterSheet.inventory.inventory[(int)slot - (int)InventorySlot.Zero]);
if (iis != null && iis.hasItem())
{
List <InventoryItemSlot> sllls = new List <InventoryItemSlot>();
if (iis.itemSlot != iis)
{
sllls.Add(iis.itemSlot);
}
foreach (InventoryItemSlot iis2 in iis.itemSlot.otherSlots)
{
if (iis2 == iis)
{
continue;
}
sllls.Add(iis2);
}
foreach (InventoryItemSlot iis2 in sllls)
{
int slotind = iis2.index;
Image img = overlayObject.transform.parent.GetChild(slotind).GetComponent <Image>();
img.color = c;
otherImages.Add(img);
}
}
}
}
else
{
Item i = selectedItem.GetComponent <InventoryItem>().item;
ActionType at = Inventory.getActionTypeForMovement(slot, originalSlot);
Debug.Log(i.itemName);
if (UnitGUI.inventorySlots.Contains(slot))
{
Vector2 currentHighlightSlot = UnitGUI.getIndexOfSlot(slot);
Vector2 originSlot = currentHighlightSlot - selectedCell;
Item i2 = selectedCharacter.characterSheet.inventory.inventory[UnitGUI.getLinearIndexFromIndex(currentHighlightSlot)].getItem();
if (i2 != null)
{
if (!selectedCharacter.characterSheet.inventory.itemCanStackWith(i2, i) || !canUseActionType(at))
{
c = badColor;
}
else
{
i = i2;
originSlot = UnitGUI.getIndexFromLinearIndex(selectedCharacter.characterSheet.inventory.inventory[UnitGUI.getLinearIndexFromIndex(currentHighlightSlot)].itemSlot.index);
}
}
else
{
if (!canUseActionType(at) || !(originSlot.y >= 0 && originSlot.x >= 0 && originSlot.x < 4 && originSlot.y < 4 && selectedCharacter.characterSheet.inventory.canInsertItemInSlot(i, originSlot)))
{
c = badColor;
}
}
foreach (Vector2 cell in i.getShape())
{
Vector2 cc = originSlot + cell;
if (cc != currentHighlightSlot && cc.x >= 0 && cc.y >= 0 && cc.x < 4 && cc.y < 4)
{
int ind = UnitGUI.getLinearIndexFromIndex(cc);
Image img = overlayObject.transform.parent.GetChild(ind).GetComponent <Image>();
img.color = c;
otherImages.Add(img);
}
}
}
else if (UnitGUI.armorSlots.Contains(slot))
{
if (!selectedCharacter.characterSheet.characterLoadout.canInsertItemInSlot(slot, i, originalSlot))
{
c = badColor;
}
}
else if (BaseManager.trapTurretInventorySlots.Contains(slot))
{
if (!baseManager.canInsertItem(i, slot) || (i is Turret) || (i is Trap))
{
c = badColor;
}
}
else if (!canUseActionType(at))
{
c = badColor;
}
else
{
// c = badColor;
}
}
if (!overlayObjectList.ContainsKey(overlayObject))
{
overlayObjectList.Add(overlayObject, otherImages);
}
overlayObject.color = c;
if (!overlayObjects.Contains(overlayObject))
{
overlayObjects.Add(overlayObject);
}
}
public void OnEndDrag(PointerEventData eventData)
{
if (!ItemInSlot)
{
return;
}
LootBox lootBox = null;
if (eventData.hovered.Count > 0)
{
// print(eventData.hovered[0]);
bool check = false;
int indx = 0;
foreach (var c in eventData.hovered)
{
if (c.gameObject.GetComponent <InventoryItemSlot>())
{
check = true;
break;
}
indx++;
}
Debug.Log("Ui invebtory check ststus: " + check);
if (check)
{
InventoryItemSlot targetslot = eventData.hovered[indx].GetComponent <InventoryItemSlot>();
if (ItemInSlot.Equiped && !targetslot.ItemInSlot && !targetslot.isLootBox)
{
Inventory inventory = dataProvider.Player.Inventory;
ItemInSlot.Equiped = false;
inventory.UnEquipItem(ItemInSlot);
}
if (targetslot.ItemInSlot)
{
ItemImage.transform.localPosition = oldPos;
}
else
{
if (!targetslot.isLootBox)
{
ItemInSlot.gameObject.SetActive(false);
dataProvider.Player.Inventory.AddItemToList(ItemInSlot);
print("Change item position: " + ItemInSlot.name);
if (targetslot.SlotID == 10)
{
Inventory inventory = dataProvider.Player.Inventory;
ItemInSlot.Equiped = true;
inventory.EquipItem(ItemInSlot);
}
targetslot.ItemInSlot = ItemInSlot;
targetslot.ItemImage.sprite = ItemImage.sprite;
ItemInSlot = null;
ItemImage.sprite = dataProvider.BattleUI.emptySprite;
ItemImage.transform.localPosition = oldPos;
}
else
{
ItemImage.transform.localPosition = oldPos;
}
}
}
else
{
Debug.Log("DropItem_2");
ItemImage.transform.localPosition = oldPos;
}
}
else
{
Debug.Log("DropItem_3");
if (isLootBox)
{
lootBox = (LootBox)dataProvider.Player.ClosesActionObject;
if (lootBox)
{
lootBox.RemoveItem(ItemInSlot);
}
}
else
{
dataProvider.Player.Inventory.RemovItemFromList(ItemInSlot);
}
ItemInSlot.gameObject.transform.position = dataProvider.Player.ItemDropPoint.position;
ItemInSlot.transform.SetParent(null);
ItemInSlot.gameObject.SetActive(true);
Inventory inventory = dataProvider.Player.Inventory;
ItemInSlot.Equiped = false;
inventory.UnEquipItem(ItemInSlot);
ItemInSlot = null;
ItemImage.sprite = dataProvider.BattleUI.emptySprite;
ItemImage.transform.localPosition = oldPos;
}
}
public void CreateInventoryItemSlot(InventoryItemSlot inventoryItemSlot)
{
inventoryItemSlots.Add(inventoryItemSlot);
}
public ItemDroppedEventData(InventoryItem inventoryItem, InventoryItemSlot inventorySlot)
{
InventoryItem = inventoryItem;
InventorySlot = inventorySlot;
}
public static void selectItem(Character characterSheet, MapGenerator mapGenerator, Unit u)
{
Vector3 mousePos = Input.mousePosition;
mousePos.y = Screen.height - mousePos.y;
foreach (InventorySlot slot in inventorySlots)
{
Rect r = UnitGUI.getInventorySlotRect(slot);
if (r.Contains(mousePos))
{
Vector2 v = getIndexOfSlot(slot);
// Debug.Log(v);
int ind = getLinearIndexFromIndex(v);
InventoryItemSlot sl = characterSheet.characterSheet.inventory.inventory[ind];
InventoryItemSlot slR = sl.itemSlot;
if (slR == null)
{
break;
}
// Item i = slR.item;
Vector2 itemSlot = Inventory.getSlotForIndex(ind);
ItemReturn ir = characterSheet.characterSheet.inventory.removeItemFromSlot(itemSlot);
selectedItem = ir.item;
if (Input.GetKey(KeyCode.LeftShift) || Input.GetKey(KeyCode.RightShift))
{
if (selectedItem.stackSize() > 1)
{
characterSheet.characterSheet.inventory.insertItemInSlot(selectedItem, itemSlot - ir.slot);
selectedItem = selectedItem.popStack();
}
}
selectedCell = ir.slot;
selectedMousePos = mousePos;
// selectedItemPos = getInventorySlotPos();
selectedItemPos = UnitGUI.getInventorySlotPos(inventorySlots[slR.index]);
selectedItemWasInSlot = inventorySlots[slR.index];
break;
}
}
// if (!GameGUI.looting || mousePos.x < groundX || mousePos.y < groundY || mousePos.x > groundX + groundWidth || mousePos.y > groundY + groundHeight) return;
Vector2 scrollOff = UnitGUI.groundScrollPosition;
float div = 20.0f;
float y = div + UnitGUI.groundY - scrollOff.y;
float mid = UnitGUI.groundX + UnitGUI.groundWidth / 2.0f + scrollOff.x;
// mousePos.y += groundScrollPosition.y;
selectedItem = null;
if (mapGenerator != null)
{
List <Item> groundItems = mapGenerator.tiles[(int)u.position.x, (int)-u.position.y].getReachableItems();
foreach (Item i in groundItems)
{
if (i.inventoryTexture == null)
{
continue;
}
// Debug.Log(mousePos.x + " " + mousePos.y + " " + mid + " " + y);
Vector2 size = i.getSize();
float x = mid - size.x * inventoryCellSize / 2.0f;
Rect r = new Rect(x, y, size.x * inventoryCellSize, size.y * UnitGUI.inventoryCellSize);
if (r.Contains(mousePos))
{
// Debug.Log(i);
selectedCell = new Vector2((int)((mousePos.x - x) / inventoryCellSize), (int)((mousePos.y - y) / inventoryCellSize));
foreach (Vector2 cell in i.getShape())
{
if (cell.x == selectedCell.x && cell.y == selectedCell.y)
{
selectedItemPos = new Vector2(x, y);
selectedMousePos = mousePos;
selectedItem = i;
selectedItemWasInSlot = InventorySlot.None;
}
}
Debug.Log(selectedCell);
if (selectedItem != null)
{
break;
}
}
y += size.y * UnitGUI.inventoryCellSize + div;
}
}
}
public void addOtherSlot(InventoryItemSlot slot)
{
otherSlots.Add(slot);
}
public static void deselectItem(Character characterSheet, MapGenerator mapGenerator, Unit u)
{
Vector3 mousePos = Input.mousePosition;
mousePos.y = Screen.height - mousePos.y;
Tile t = (mapGenerator != null && u != null ? mapGenerator.tiles[(int)u.position.x, (int)-u.position.y] : null);
foreach (InventorySlot slot in inventorySlots)
{
Rect r = UnitGUI.getInventorySlotRect(slot);
if (r.Contains(mousePos))
{
Vector2 v2 = getIndexOfSlot(slot);
Vector2 v = v2 - selectedCell;
Debug.Log(v);
if (characterSheet.characterSheet.inventory.canInsertItemInSlot(selectedItem, v))
{
if (selectedItemWasInSlot == InventorySlot.None)
{
t.removeItem(selectedItem, 1);
u.useMinor(MinorType.Loot, false, false);
}
characterSheet.characterSheet.inventory.insertItemInSlot(selectedItem, v);
selectedItem = null;
return;
}
else
{
InventoryItemSlot invSlot = characterSheet.characterSheet.inventory.inventory[Inventory.getIndexForSlot(v2)];
Item invSlotItem = invSlot.getItem();
if (invSlotItem != null && characterSheet.characterSheet.inventory.itemCanStackWith(invSlotItem, selectedItem))
{
if (selectedItemWasInSlot == InventorySlot.None)
{
t.removeItem(selectedItem, 1);
u.useMinor(MinorType.Loot, false, false);
}
characterSheet.characterSheet.inventory.stackItemWith(invSlotItem, selectedItem);
selectedItem = null;
return;
}
}
break;
}
}
/* if (GameGUI.looting && !(mousePos.x < groundX || mousePos.y < groundY || mousePos.x > groundX + groundWidth || mousePos.y > groundY + groundHeight)) {
* if (selectedItemWasInSlot!=InventorySlot.None && selectedItem!=null) {
* while (selectedItem.stackSize() > 1) t.addItem(selectedItem.popStack());
* t.addItem(selectedItem);
* u.useMinor(MinorType.Loot, false, false);
* // characterSheet.characterSheet.inventory.removeItemFromSlot(getInventorySlotPos(selectedItemWasInSlot));
* }
* }
* else if (selectedItemWasInSlot!=InventorySlot.None) {
* if (characterSheet.characterSheet.inventory.canInsertItemInSlot(selectedItem, getIndexOfSlot(selectedItemWasInSlot))) {
* characterSheet.characterSheet.inventory.insertItemInSlot(selectedItem, getIndexOfSlot(selectedItemWasInSlot));
* }
* else {
* int slot1 = getLinearIndexFromIndex(getIndexOfSlot(selectedItemWasInSlot));
* if (slot1 > -1 && characterSheet.characterSheet.inventory.itemCanStackWith(characterSheet.characterSheet.inventory.inventory[slot1].getItem(),selectedItem)) {
* characterSheet.characterSheet.inventory.stackItemWith(characterSheet.characterSheet.inventory.inventory[slot1].getItem(),selectedItem);
* }
* }
* }*/
selectedItem = null;
}
public void removeItem()
{
item = null; itemSlot = null; otherSlots = new List <InventoryItemSlot>();
}
