| public checkIfItemAllreadyExist ( int itemID, int itemValue ) : bool | ||
| itemID | int | |
| itemValue | int | |
| 리턴 | bool | |
// Update is called once per frame
void Update()
{
if (_inventory != null && UserControl.PickupItem)
{
float distance = Vector2.Distance(new Vector2(this.gameObject.transform.position.x, this.gameObject.transform.position.y), new Vector2(_player.transform.position.x, _player.transform.position.y));
print("distance: " + distance);
if (distance <= 1.3)
{
sceneManager.GetComponent <MySceneManager>().removeFromGearList(this.gameObject);
bool check = _inventory.checkIfItemAllreadyExist(item.itemID, item.itemValue);
if (check)
{
Destroy(this.gameObject);
}
else if (_inventory.ItemsInInventory.Count < (_inventory.width * _inventory.height))
{
_inventory.addItemToInventory(item.itemID, item.itemValue);
_inventory.updateItemList();
_inventory.stackableSettings();
Destroy(this.gameObject);
}
}
}
if (_inventory != null && UserControl.GetGearsBack)
{
addItemToInv(item.itemID, item.itemValue);
}
}
// Update is called once per frame
void Update()
{
Vector3 newPos = this.gameObject.transform.position;
// characPos = center of the player;
Vector3 characPos = _player.transform.position;
characPos.y += _player.transform.localScale.y / 2;
float distance = Vector3.Distance(this.gameObject.transform.position, characPos);
speedMultiplier = distance * 0.05f;
if (distance <= 1)
{
pi.brokenItemID = this.gameObject.GetComponent <PickUpItem>().item.itemID;
if (!pi.FullInventory())
{
// moving the item to the player
if (newPos.x - characPos.x < 0)
{
newPos.x += speedMultiplier;
}
else if (newPos.x - characPos.x > 0)
{
newPos.x -= speedMultiplier;
}
if (newPos.y - characPos.y < 0)
{
newPos.y += speedMultiplier;
}
else if (newPos.y - characPos.y > 0)
{
newPos.y -= speedMultiplier;
}
this.gameObject.transform.position = newPos;
// picking up the item
if (_inventory != null && Mathf.Abs(this.gameObject.transform.position.x - characPos.x) <= 0.3f &&
Mathf.Abs(this.gameObject.transform.position.y - characPos.y) <= 0.3f * (_player.GetComponent <CapsuleCollider2D>().offset.y / _player.GetComponent <CapsuleCollider2D>().offset.x))
{
bool check = _inventory.checkIfItemAllreadyExist(item.itemID, item.itemValue);
if (check)
{
Destroy(this.gameObject);
}
else if (_inventory.ItemsInInventory.Count < (_inventory.width * _inventory.height))
{
_inventory.addItemToInventory(item.itemID, item.itemValue);
_inventory.updateItemList();
_inventory.stackableSettings();
Destroy(this.gameObject);
}
if (!pi.currentLevel.Equals(pi.maxLevel))
{
pi.GainExp(item.expToGain);
}
}
}
}
}
// Update is called once per frame
void Update()
{
if (_inventory != null && Input.GetKeyDown(KeyCode.E))
{
RaycastHit hit;
if (Physics.Raycast(Camera.main.transform.position, Camera.main.transform.forward, out hit, 3f))
{
if (!hit.transform.gameObject.GetComponent <PickUpItem>())
{
return;
}
bool check = _inventory.checkIfItemAllreadyExist(item.itemID, item.itemValue);
if (check)
{
Destroy(this.gameObject);
}
else if (_inventory.ItemsInInventory.Count < (_inventory.width * _inventory.height))
{
_inventory.addItemToInventory(item.itemID, item.itemValue);
_inventory.updateItemList();
_inventory.stackableSettings();
Destroy(this.gameObject);
}
}
}
}
// Update is called once per frame
void Update()
{
if (inventory != null)
{
float distance1 = Vector3.Distance(this.gameObject.transform.position, player1.transform.position);
float distance2 = Vector3.Distance(this.gameObject.transform.position, player2.transform.position);
if (distance1 <= 2 || distance2 <= 2)
{
bool check = inventory.checkIfItemAllreadyExist(item.itemID, item.itemValue);
if (check)
{
Destroy(this.gameObject);
}
else if (inventory.ItemsInInventory.Count < (inventory.width * inventory.height))
{
inventory.addItemToInventory(item.itemID, item.itemValue);
ThisScene.AddItemToPersistedInventory(item.itemID);
Destroy(this.gameObject);
if (pickUpFX != null)
{
AudioSource.PlayClipAtPoint(pickUpFX, transform.position);
}
}
}
}
}
// Update is called once per frame
void Update()
{
if (_inventory != null && Input.GetKeyDown(KeyCode.E))
{
float distance = Vector3.Distance(this.gameObject.transform.position, _player.transform.position);
if (distance <= 3)
{
if (playerIO.isNetwork)
{
menuManager.Debuglog("Собранно " + item.itemName + " колличество " + item.itemValue);
//MenuManager.instance.Debuglog();
GameObject.Find("NetworkManager").GetComponent <NetworkLayerClient>().HarwestWood(item.itemID, item.itemValue);
Destroy(this.gameObject);
}
else
{
Debug.Log("Собранно " + item.itemName + " колличество " + item.itemValue);
bool check = _inventory.checkIfItemAllreadyExist(item.itemID, item.itemValue);
if (check)
{
Destroy(this.gameObject);
}
else if (_inventory.ItemsInInventory.Count < (_inventory.width * _inventory.height))
{
_inventory.addItemToInventory(item.itemID, item.itemValue);
_inventory.updateItemList();
_inventory.stackableSettings();
Destroy(this.gameObject);
}
}
}
}
}
public void addItemToInventory(int id, int value = 1)
{
if (mainInventory == null)
{
mainInventory = inventory.GetComponent <Inventory>();
}
if (!mainInventory.checkIfItemAllreadyExist(id, value))
{
mainInventory.addItemToInventory(id, value);
}
}
public override void Interact()
{
base.Interact();
bool check = _inventory.checkIfItemAllreadyExist(item.itemID, item.itemValue);
if (check)
{
Destroy(this.gameObject);
}
else if (_inventory.ItemsInInventory.Count < (_inventory.width * _inventory.height))
{
_inventory.addItemToInventory(item.itemID, item.itemValue);
_inventory.updateIconSize();
_inventory.updateItemList();
_inventory.stackableSettings();
Destroy(this.gameObject);
GameManager.NotifyPickedUpItem(item);
}
}
// Update is called once per frame
void Update()
{
if (_inventory != null && Input.GetKeyDown(KeyCode.E))
{
float distance = Vector3.Distance(this.gameObject.transform.position, _player.transform.position);
if (distance <= 3)
{
bool check = _inventory.checkIfItemAllreadyExist(item.itemID, item.itemValue);
if (check)
{
Destroy(this.gameObject);
}
else if (_inventory.ItemsInInventory.Count < (_inventory.width * _inventory.height))
{
_inventory.addItemToInventory(item.itemID, item.itemValue);
_inventory.updateItemList();
_inventory.stackableSettings();
Destroy(this.gameObject);
}
}
}
}
public void OnEndDrag(PointerEventData data)
{
if (data.button == PointerEventData.InputButton.Left)
{
canvasGroup.blocksRaycasts = true;
Transform newSlot = null;
if (data.pointerEnter != null)
{
newSlot = data.pointerEnter.transform;
}
if (newSlot != null)
{
//getting the items from the slots, GameObjects and RectTransform
GameObject firstItemGameObject = this.gameObject;
GameObject secondItemGameObject = newSlot.parent.gameObject;
RectTransform firstItemRectTransform = this.gameObject.GetComponent <RectTransform>();
RectTransform secondItemRectTransform = newSlot.parent.GetComponent <RectTransform>();
if (secondItemRectTransform == null)
{
return;
}
bool byitemonitem = false;
Item firstItem = rectTransform.GetComponent <ItemOnObject>().item;
Item secondItem = new Item();
if (newSlot.parent.GetComponent <ItemOnObject>() != null)
{
secondItem = newSlot.parent.GetComponent <ItemOnObject>().item;
}
if (secondItemRectTransform.gameObject.name != "PlayerGui")
{
if (firstItemRectTransform.gameObject.name == "Item(Clone)" && secondItemRectTransform.gameObject.name == "Item(Clone)")
{
Debug.Log("Dragitem " + secondItemRectTransform.parent.parent.parent.name);
if (secondItemRectTransform.parent.parent.parent.tag == "MainInventory" || secondItemRectTransform.parent.parent.parent.tag == "Hotbar")
{
byitemonitem = true;
}
}
//Debug.Log("Error By " + firstItem.outbox.tag+"secondItemRectTransform "+ secondItemRectTransform.gameObject.name);
if ((firstItem.outbox.tag == "Shop" && secondItemRectTransform.parent.gameObject.tag == "MainInventory") || (firstItem.outbox.tag == "Shop" && secondItemRectTransform.parent.gameObject.tag == "Hotbar") || byitemonitem)
{
int pricemengnt = firstItem.price * 10;
int PlayerMoney = 0;
if (playerIO.isNetwork)
{
PlayerMoney = networkLayerClient.player.money;
}
else
{
PlayerMoney = GameObject.Find("GameLocal").GetComponent <Gamelocal>().PlayerMoney;
}
if (PlayerMoney < pricemengnt)
{
if (playerIO.isNetwork)
{
MenuManager.instance.Debuglog("Нехватает денег");
}
else
{
GameObject.Find("GameLocal").GetComponent <Gamelocal>().Debuglog("Нехватает денег");
}
Item returitem = firstItem;
Inventory shopinventory = returitem.outbox.GetComponent <Inventory>();
//Component[] components = returitem.outbox.GetComponents<Inventory>();
shopinventory.addItemToInventory(returitem.itemID, returitem.itemValue);
shopinventory.OnUpdateItemList();
Destroy(rectTransform.gameObject);
return;
}
else
{
if (playerIO.isNetwork)
{
PlayerMoney = networkLayerClient.player.money;
networkLayerClient.buy_items(firstItem, 1);
//buy_items
}
else
{
PlayerMoney -= pricemengnt;
PlayerMoney = GameObject.Find("GameLocal").GetComponent <Gamelocal>().PlayerMoney;
Inventory playerinventory = GameObject.Find("PlayerGui").transform.GetChild(1).GetComponent <Inventory>();
//createDuplication(GameObject Item)
if (!playerinventory.checkIfItemAllreadyExist(firstItem.itemID, 1))
{
playerinventory.addItemToInventory(firstItem.itemID);
}
}
Item returitem = firstItem;
Inventory shopinventory = returitem.outbox.GetComponent <Inventory>();
//Component[] components = returitem.outbox.GetComponents<Inventory>();
shopinventory.addItemToInventory(returitem.itemID, returitem.itemValue);
shopinventory.OnUpdateItemList();
Destroy(rectTransform.gameObject);
return;
}
// Debug.Log("By item previem box" + firstItem.outbox.tag + " newSlot" + secondItemRectTransform.parent.gameObject.tag);
}
}
if (secondItemRectTransform.gameObject.name == "PlayerGui")
{
Item returitem = firstItem;
Inventory shopinventory = returitem.outbox.GetComponent <Inventory>();
//Component[] components = returitem.outbox.GetComponents<Inventory>();
shopinventory.addItemToInventory(returitem.itemID, returitem.itemValue);
shopinventory.OnUpdateItemList();
Destroy(rectTransform.gameObject);
return;
}
if (firstItemRectTransform.gameObject.name == "Item(Clone)" && secondItemRectTransform.gameObject.name == "Item(Clone)")
{
Debug.Log("Dragitem " + secondItemRectTransform.parent.parent.parent.name);
if (secondItemRectTransform.parent.parent.parent.tag == "Shop")
{
byitemonitem = true;
}
}
if ((firstItem.outbox.tag == "MainInventory" && secondItemRectTransform.parent.gameObject.tag == "Shop") || (firstItem.outbox.tag == "Hotbar" && secondItemRectTransform.parent.gameObject.tag == "Shop") || byitemonitem)
{
// Gamelocal.instance.PlayerMoney = Gamelocal.instance.PlayerMoney + (firstItem.price * firstItem.itemValue);
if (playerIO.isNetwork)
{
networkLayerClient.sell_items(firstItem);
}
else
{
int PlayerMoney = GameObject.Find("GameLocal").GetComponent <Gamelocal>().PlayerMoney;
PlayerMoney += firstItem.price * firstItem.itemValue;
GameObject.Find("GameLocal").GetComponent <Gamelocal>().PlayerMoney = PlayerMoney;
}
Destroy(rectTransform.gameObject);
Debug.Log("Sell item previem box" + firstItem.outbox.tag + " newSlot" + secondItemRectTransform.parent.gameObject.tag);
return;
}
//get some informations about the two items
bool sameItem = firstItem.itemName == secondItem.itemName;
bool sameItemRerferenced = firstItem.Equals(secondItem);
bool secondItemStack = false;
bool firstItemStack = false;
if (sameItem)
{
firstItemStack = firstItem.itemValue < firstItem.maxStack;
secondItemStack = secondItem.itemValue < secondItem.maxStack;
}
// Debug.Log("Error By " + firstItemRectTransform.gameObject.name + " secondItemRectTransform "+ secondItemRectTransform.gameObject.name);
if (secondItemRectTransform.gameObject.name == "PlayerGui")
{
Item returitem = firstItem;
Inventory shopinventory = returitem.outbox.GetComponent <Inventory>();
//Component[] components = returitem.outbox.GetComponents<Inventory>();
shopinventory.addItemToInventory(returitem.itemID, returitem.itemValue);
shopinventory.OnUpdateItemList();
Destroy(rectTransform.gameObject);
return;
}
GameObject Inventory = secondItemRectTransform.parent.gameObject;
if (Inventory.tag == "Slot")
{
Inventory = secondItemRectTransform.parent.parent.parent.gameObject;
}
if (Inventory.tag.Equals("Slot"))
{
Inventory = Inventory.transform.parent.parent.gameObject;
}
//dragging in an Inventory
if (Inventory.GetComponent <Hotbar>() == null && Inventory.GetComponent <EquipmentSystem>() == null && Inventory.GetComponent <CraftSystem>() == null)
{
//you cannot attach items to the resultslot of the craftsystem
if (newSlot.transform.parent.tag == "ResultSlot" || newSlot.transform.tag == "ResultSlot" || newSlot.transform.parent.parent.tag == "ResultSlot")
{
firstItemGameObject.transform.SetParent(oldSlot.transform);
firstItemRectTransform.localPosition = Vector3.zero;
}
else
{
int newSlotChildCount = newSlot.transform.parent.childCount;
bool isOnSlot = newSlot.transform.parent.GetChild(0).tag == "ItemIcon";
//dragging on a slot where allready is an item on
if (newSlotChildCount != 0 && isOnSlot)
{
//check if the items fits into the other item
bool fitsIntoStack = false;
if (sameItem)
{
fitsIntoStack = (firstItem.itemValue + secondItem.itemValue) <= firstItem.maxStack;
}
//if the item is stackable checking if the firstitemstack and seconditemstack is not full and check if they are the same items
if (inventory.stackable && sameItem && firstItemStack && secondItemStack)
{
//if the item does not fit into the other item
if (fitsIntoStack && !sameItemRerferenced)
{
secondItem.itemValue = firstItem.itemValue + secondItem.itemValue;
secondItemGameObject.transform.SetParent(newSlot.parent.parent);
Destroy(firstItemGameObject);
secondItemRectTransform.localPosition = Vector3.zero;
if (secondItemGameObject.GetComponent <ConsumeItem>().duplication != null)
{
GameObject dup = secondItemGameObject.GetComponent <ConsumeItem>().duplication;
dup.GetComponent <ItemOnObject>().item.itemValue = secondItem.itemValue;
dup.GetComponent <SplitItem>().inv.stackableSettings();
dup.transform.parent.parent.parent.GetComponent <Inventory>().updateItemList();
}
}
else
{
//creates the rest of the item
int rest = (firstItem.itemValue + secondItem.itemValue) % firstItem.maxStack;
//fill up the other stack and adds the rest to the other stack
if (!fitsIntoStack && rest > 0)
{
firstItem.itemValue = firstItem.maxStack;
secondItem.itemValue = rest;
firstItemGameObject.transform.SetParent(secondItemGameObject.transform.parent);
secondItemGameObject.transform.SetParent(oldSlot.transform);
firstItemRectTransform.localPosition = Vector3.zero;
secondItemRectTransform.localPosition = Vector3.zero;
}
}
}
//if does not fit
else
{
//creates the rest of the item
int rest = 0;
if (sameItem)
{
rest = (firstItem.itemValue + secondItem.itemValue) % firstItem.maxStack;
}
//fill up the other stack and adds the rest to the other stack
if (!fitsIntoStack && rest > 0)
{
secondItem.itemValue = firstItem.maxStack;
firstItem.itemValue = rest;
firstItemGameObject.transform.SetParent(secondItemGameObject.transform.parent);
secondItemGameObject.transform.SetParent(oldSlot.transform);
firstItemRectTransform.localPosition = Vector3.zero;
secondItemRectTransform.localPosition = Vector3.zero;
}
//if they are different items or the stack is full, they get swapped
else if (!fitsIntoStack && rest == 0)
{
//if you are dragging an item from equipmentsystem to the inventory and try to swap it with the same itemtype
if (oldSlot.transform.parent.parent.GetComponent <EquipmentSystem>() != null && firstItem.itemType == secondItem.itemType)
{
newSlot.transform.parent.parent.parent.parent.GetComponent <Inventory>().UnEquipItem1(firstItem);
oldSlot.transform.parent.parent.GetComponent <Inventory>().EquiptItem(secondItem);
firstItemGameObject.transform.SetParent(secondItemGameObject.transform.parent);
secondItemGameObject.transform.SetParent(oldSlot.transform);
secondItemRectTransform.localPosition = Vector3.zero;
firstItemRectTransform.localPosition = Vector3.zero;
if (secondItemGameObject.GetComponent <ConsumeItem>().duplication != null)
{
Destroy(secondItemGameObject.GetComponent <ConsumeItem>().duplication);
}
}
//if you are dragging an item from the equipmentsystem to the inventory and they are not from the same itemtype they do not get swapped.
else if (oldSlot.transform.parent.parent.GetComponent <EquipmentSystem>() != null && firstItem.itemType != secondItem.itemType)
{
firstItemGameObject.transform.SetParent(oldSlot.transform);
firstItemRectTransform.localPosition = Vector3.zero;
}
//swapping for the rest of the inventorys
else if (oldSlot.transform.parent.parent.GetComponent <EquipmentSystem>() == null)
{
firstItemGameObject.transform.SetParent(secondItemGameObject.transform.parent);
secondItemGameObject.transform.SetParent(oldSlot.transform);
secondItemRectTransform.localPosition = Vector3.zero;
firstItemRectTransform.localPosition = Vector3.zero;
}
}
}
}
//empty slot
else
{
if (newSlot.tag != "Slot" && newSlot.tag != "ItemIcon")
{
firstItemGameObject.transform.SetParent(oldSlot.transform);
firstItemRectTransform.localPosition = Vector3.zero;
}
else
{
firstItemGameObject.transform.SetParent(newSlot.transform);
firstItemRectTransform.localPosition = Vector3.zero;
if (newSlot.transform.parent.parent.GetComponent <EquipmentSystem>() == null && oldSlot.transform.parent.parent.GetComponent <EquipmentSystem>() != null)
{
oldSlot.transform.parent.parent.GetComponent <Inventory>().UnEquipItem1(firstItem);
}
}
}
}
}
//dragging into a Hotbar
if (Inventory.GetComponent <Hotbar>() != null)
{
int newSlotChildCount = newSlot.transform.parent.childCount;
bool isOnSlot = newSlot.transform.parent.GetChild(0).tag == "ItemIcon";
//dragging on a slot where allready is an item on
if (newSlotChildCount != 0 && isOnSlot)
{
//check if the items fits into the other item
bool fitsIntoStack = false;
if (sameItem)
{
fitsIntoStack = (firstItem.itemValue + secondItem.itemValue) <= firstItem.maxStack;
}
//if the item is stackable checking if the firstitemstack and seconditemstack is not full and check if they are the same items
if (inventory.stackable && sameItem && firstItemStack && secondItemStack)
{
//if the item does not fit into the other item
if (fitsIntoStack && !sameItemRerferenced)
{
secondItem.itemValue = firstItem.itemValue + secondItem.itemValue;
secondItemGameObject.transform.SetParent(newSlot.parent.parent);
Destroy(firstItemGameObject);
secondItemRectTransform.localPosition = Vector3.zero;
if (secondItemGameObject.GetComponent <ConsumeItem>().duplication != null)
{
GameObject dup = secondItemGameObject.GetComponent <ConsumeItem>().duplication;
dup.GetComponent <ItemOnObject>().item.itemValue = secondItem.itemValue;
Inventory.GetComponent <Inventory>().stackableSettings();
dup.transform.parent.parent.parent.GetComponent <Inventory>().updateItemList();
}
}
else
{
//creates the rest of the item
int rest = (firstItem.itemValue + secondItem.itemValue) % firstItem.maxStack;
//fill up the other stack and adds the rest to the other stack
if (!fitsIntoStack && rest > 0)
{
firstItem.itemValue = firstItem.maxStack;
secondItem.itemValue = rest;
firstItemGameObject.transform.SetParent(secondItemGameObject.transform.parent);
secondItemGameObject.transform.SetParent(oldSlot.transform);
firstItemRectTransform.localPosition = Vector3.zero;
secondItemRectTransform.localPosition = Vector3.zero;
createDuplication(this.gameObject);
secondItemGameObject.GetComponent <ConsumeItem>().duplication.GetComponent <ItemOnObject>().item = secondItem;
secondItemGameObject.GetComponent <SplitItem>().inv.stackableSettings();
}
}
}
//if does not fit
else
{
//creates the rest of the item
int rest = 0;
if (sameItem)
{
rest = (firstItem.itemValue + secondItem.itemValue) % firstItem.maxStack;
}
bool fromEquip = oldSlot.transform.parent.parent.GetComponent <EquipmentSystem>() != null;
//fill up the other stack and adds the rest to the other stack
if (!fitsIntoStack && rest > 0)
{
secondItem.itemValue = firstItem.maxStack;
firstItem.itemValue = rest;
createDuplication(this.gameObject);
firstItemGameObject.transform.SetParent(secondItemGameObject.transform.parent);
secondItemGameObject.transform.SetParent(oldSlot.transform);
firstItemRectTransform.localPosition = Vector3.zero;
secondItemRectTransform.localPosition = Vector3.zero;
}
//if they are different items or the stack is full, they get swapped
else if (!fitsIntoStack && rest == 0)
{
if (!fromEquip)
{
firstItemGameObject.transform.SetParent(secondItemGameObject.transform.parent);
secondItemGameObject.transform.SetParent(oldSlot.transform);
secondItemRectTransform.localPosition = Vector3.zero;
firstItemRectTransform.localPosition = Vector3.zero;
if (oldSlot.transform.parent.parent.gameObject.Equals(GameObject.FindGameObjectWithTag("MainInventory")))
{
Destroy(secondItemGameObject.GetComponent <ConsumeItem>().duplication);
createDuplication(firstItemGameObject);
}
else
{
createDuplication(firstItemGameObject);
}
}
else
{
firstItemGameObject.transform.SetParent(oldSlot.transform);
firstItemRectTransform.localPosition = Vector3.zero;
}
}
}
}
//empty slot
else
{
if (newSlot.tag != "Slot" && newSlot.tag != "ItemIcon")
{
firstItemGameObject.transform.SetParent(oldSlot.transform);
firstItemRectTransform.localPosition = Vector3.zero;
}
else
{
firstItemGameObject.transform.SetParent(newSlot.transform);
firstItemRectTransform.localPosition = Vector3.zero;
if (newSlot.transform.parent.parent.GetComponent <EquipmentSystem>() == null && oldSlot.transform.parent.parent.GetComponent <EquipmentSystem>() != null)
{
oldSlot.transform.parent.parent.GetComponent <Inventory>().UnEquipItem1(firstItem);
}
createDuplication(firstItemGameObject);
}
}
}
//dragging into a equipmentsystem/charactersystem
if (Inventory.GetComponent <EquipmentSystem>() != null)
{
ItemType[] itemTypeOfSlots = GameObject.FindGameObjectWithTag("EquipmentSystem").GetComponent <EquipmentSystem>().itemTypeOfSlots;
int newSlotChildCount = newSlot.transform.parent.childCount;
bool isOnSlot = newSlot.transform.parent.GetChild(0).tag == "ItemIcon";
bool sameItemType = firstItem.itemType == secondItem.itemType;
bool fromHot = oldSlot.transform.parent.parent.GetComponent <Hotbar>() != null;
//dragging on a slot where allready is an item on
if (newSlotChildCount != 0 && isOnSlot)
{
//items getting swapped if they are the same itemtype
if (sameItemType && !sameItemRerferenced) //
{
Transform temp1 = secondItemGameObject.transform.parent.parent.parent;
Transform temp2 = oldSlot.transform.parent.parent;
firstItemGameObject.transform.SetParent(secondItemGameObject.transform.parent);
secondItemGameObject.transform.SetParent(oldSlot.transform);
secondItemRectTransform.localPosition = Vector3.zero;
firstItemRectTransform.localPosition = Vector3.zero;
if (!temp1.Equals(temp2))
{
if (firstItem.itemType == ItemType.UFPS_Weapon)
{
Inventory.GetComponent <Inventory>().UnEquipItem1(secondItem);
Inventory.GetComponent <Inventory>().EquiptItem(firstItem);
}
else
{
Inventory.GetComponent <Inventory>().EquiptItem(firstItem);
if (secondItem.itemType != ItemType.Backpack)
{
Inventory.GetComponent <Inventory>().UnEquipItem1(secondItem);
}
}
}
if (fromHot)
{
createDuplication(secondItemGameObject);
}
}
//if they are not from the same Itemtype the dragged one getting placed back
else
{
firstItemGameObject.transform.SetParent(oldSlot.transform);
firstItemRectTransform.localPosition = Vector3.zero;
if (fromHot)
{
createDuplication(firstItemGameObject);
}
}
}
//if the slot is empty
else
{
for (int i = 0; i < newSlot.parent.childCount; i++)
{
if (newSlot.Equals(newSlot.parent.GetChild(i)))
{
//checking if it is the right slot for the item
if (itemTypeOfSlots[i] == transform.GetComponent <ItemOnObject>().item.itemType)
{
transform.SetParent(newSlot);
rectTransform.localPosition = Vector3.zero;
if (!oldSlot.transform.parent.parent.Equals(newSlot.transform.parent.parent))
{
Inventory.GetComponent <Inventory>().EquiptItem(firstItem);
}
}
//else it get back to the old slot
else
{
transform.SetParent(oldSlot.transform);
rectTransform.localPosition = Vector3.zero;
if (fromHot)
{
createDuplication(firstItemGameObject);
}
}
}
}
}
}
if (Inventory.GetComponent <CraftSystem>() != null)
{
CraftSystem cS = Inventory.GetComponent <CraftSystem>();
int newSlotChildCount = newSlot.transform.parent.childCount;
bool isOnSlot = newSlot.transform.parent.GetChild(0).tag == "ItemIcon";
//dragging on a slot where allready is an item on
if (newSlotChildCount != 0 && isOnSlot)
{
//check if the items fits into the other item
bool fitsIntoStack = false;
if (sameItem)
{
fitsIntoStack = (firstItem.itemValue + secondItem.itemValue) <= firstItem.maxStack;
}
//if the item is stackable checking if the firstitemstack and seconditemstack is not full and check if they are the same items
if (inventory.stackable && sameItem && firstItemStack && secondItemStack)
{
//if the item does not fit into the other item
if (fitsIntoStack && !sameItemRerferenced)
{
secondItem.itemValue = firstItem.itemValue + secondItem.itemValue;
secondItemGameObject.transform.SetParent(newSlot.parent.parent);
Destroy(firstItemGameObject);
secondItemRectTransform.localPosition = Vector3.zero;
if (secondItemGameObject.GetComponent <ConsumeItem>().duplication != null)
{
GameObject dup = secondItemGameObject.GetComponent <ConsumeItem>().duplication;
dup.GetComponent <ItemOnObject>().item.itemValue = secondItem.itemValue;
dup.GetComponent <SplitItem>().inv.stackableSettings();
dup.transform.parent.parent.parent.GetComponent <Inventory>().updateItemList();
}
cS.ListWithItem();
}
else
{
//creates the rest of the item
int rest = (firstItem.itemValue + secondItem.itemValue) % firstItem.maxStack;
//fill up the other stack and adds the rest to the other stack
if (!fitsIntoStack && rest > 0)
{
firstItem.itemValue = firstItem.maxStack;
secondItem.itemValue = rest;
firstItemGameObject.transform.SetParent(secondItemGameObject.transform.parent);
secondItemGameObject.transform.SetParent(oldSlot.transform);
firstItemRectTransform.localPosition = Vector3.zero;
secondItemRectTransform.localPosition = Vector3.zero;
cS.ListWithItem();
}
}
}
//if does not fit
else
{
//creates the rest of the item
int rest = 0;
if (sameItem)
{
rest = (firstItem.itemValue + secondItem.itemValue) % firstItem.maxStack;
}
//fill up the other stack and adds the rest to the other stack
if (!fitsIntoStack && rest > 0)
{
secondItem.itemValue = firstItem.maxStack;
firstItem.itemValue = rest;
firstItemGameObject.transform.SetParent(secondItemGameObject.transform.parent);
secondItemGameObject.transform.SetParent(oldSlot.transform);
firstItemRectTransform.localPosition = Vector3.zero;
secondItemRectTransform.localPosition = Vector3.zero;
cS.ListWithItem();
}
//if they are different items or the stack is full, they get swapped
else if (!fitsIntoStack && rest == 0)
{
//if you are dragging an item from equipmentsystem to the inventory and try to swap it with the same itemtype
if (oldSlot.transform.parent.parent.GetComponent <EquipmentSystem>() != null && firstItem.itemType == secondItem.itemType)
{
firstItemGameObject.transform.SetParent(secondItemGameObject.transform.parent);
secondItemGameObject.transform.SetParent(oldSlot.transform);
secondItemRectTransform.localPosition = Vector3.zero;
firstItemRectTransform.localPosition = Vector3.zero;
oldSlot.transform.parent.parent.GetComponent <Inventory>().EquiptItem(secondItem);
newSlot.transform.parent.parent.parent.parent.GetComponent <Inventory>().UnEquipItem1(firstItem);
}
//if you are dragging an item from the equipmentsystem to the inventory and they are not from the same itemtype they do not get swapped.
else if (oldSlot.transform.parent.parent.GetComponent <EquipmentSystem>() != null && firstItem.itemType != secondItem.itemType)
{
firstItemGameObject.transform.SetParent(oldSlot.transform);
firstItemRectTransform.localPosition = Vector3.zero;
}
//swapping for the rest of the inventorys
else if (oldSlot.transform.parent.parent.GetComponent <EquipmentSystem>() == null)
{
firstItemGameObject.transform.SetParent(secondItemGameObject.transform.parent);
secondItemGameObject.transform.SetParent(oldSlot.transform);
secondItemRectTransform.localPosition = Vector3.zero;
firstItemRectTransform.localPosition = Vector3.zero;
}
}
}
}
else
{
if (newSlot.tag != "Slot" && newSlot.tag != "ItemIcon")
{
firstItemGameObject.transform.SetParent(oldSlot.transform);
firstItemRectTransform.localPosition = Vector3.zero;
}
else
{
firstItemGameObject.transform.SetParent(newSlot.transform);
firstItemRectTransform.localPosition = Vector3.zero;
if (newSlot.transform.parent.parent.GetComponent <EquipmentSystem>() == null && oldSlot.transform.parent.parent.GetComponent <EquipmentSystem>() != null)
{
oldSlot.transform.parent.parent.GetComponent <Inventory>().UnEquipItem1(firstItem);
}
}
}
}
}
else
{
if (GetComponent <ItemOnObject>().item.outbox.tag == "Shop")
{
Item returitem = GetComponent <ItemOnObject>().item;
Inventory shopinventory = returitem.outbox.GetComponent <Inventory>();
Component[] components = returitem.outbox.GetComponents <Inventory>();
shopinventory.addItemToInventory(returitem.itemID, returitem.itemValue);
shopinventory.OnUpdateItemList();
Destroy(this.gameObject);
}
else
{
GameObject dropItem = (GameObject)Instantiate(GetComponent <ItemOnObject>().item.itemModel);
dropItem.AddComponent <PickUpItem>();
dropItem.GetComponent <PickUpItem>().item = this.gameObject.GetComponent <ItemOnObject>().item;
dropItem.transform.localPosition = GameObject.FindGameObjectWithTag("Player").transform.localPosition;
inventory.OnUpdateItemList();
if (oldSlot.transform.parent.parent.GetComponent <EquipmentSystem>() != null)
{
inventory.GetComponent <Inventory>().UnEquipItem1(dropItem.GetComponent <PickUpItem>().item);
}
Destroy(this.gameObject);
}
}
}
inventory.OnUpdateItemList();
}
public void OnPointerDown(PointerEventData data)
{
if (this.gameObject.transform.parent.parent.parent.GetComponent <EquipmentSystem>() == null)
{
bool gearable = false;
Inventory inventory = transform.parent.parent.parent.GetComponent <Inventory>();
if (eS != null)
{
itemTypeOfSlot = eS.itemTypeOfSlots;
}
if (data.button == PointerEventData.InputButton.Right)
{
//item from craft system to inventory
if (transform.parent.GetComponent <CraftResultSlot>() != null)
{
var playerInv = playerInventory.inventory.GetComponent <Inventory>();
bool check = inventory.checkIfItemAllreadyExist(item.itemID, item.itemValue);
if (!check)
{
playerInv.addItemToInventory(item.itemID, item.itemValue);
playerInv.stackableSettings();
}
CraftSystem cS = playerInventory.craftSystem.GetComponent <CraftSystem>();
cS.deleteItems(item);
CraftResultSlot result = playerInventory.craftSystem.transform.GetChild(3).GetComponent <CraftResultSlot>();
result.temp = 0;
tooltip.deactivateTooltip();
gearable = true;
GameObject.FindGameObjectWithTag("MainInventory").GetComponent <Inventory>().updateItemList();
}
else
{
bool stop = false;
if (eS != null)
{
for (int i = 0; i < eS.slotsInTotal; i++)
{
if (itemTypeOfSlot[i].Equals(item.itemType))
{
if (eS.transform.GetChild(1).GetChild(i).childCount == 0)
{
stop = true;
if (eS.transform.GetChild(1).GetChild(i).parent.parent.GetComponent <EquipmentSystem>() != null && this.gameObject.transform.parent.parent.parent.GetComponent <EquipmentSystem>() != null)
{
}
else
{
inventory.EquiptItem(item);
}
this.gameObject.transform.SetParent(eS.transform.GetChild(1).GetChild(i));
this.gameObject.GetComponent <RectTransform>().localPosition = Vector3.zero;
eS.gameObject.GetComponent <Inventory>().updateItemList();
inventory.updateItemList();
gearable = true;
if (duplication != null)
{
Destroy(duplication.gameObject);
}
break;
}
}
}
if (!stop)
{
for (int i = 0; i < eS.slotsInTotal; i++)
{
if (itemTypeOfSlot[i].Equals(item.itemType))
{
if (eS.transform.GetChild(1).GetChild(i).childCount != 0)
{
GameObject otherItemFromCharacterSystem = eS.transform.GetChild(1).GetChild(i).GetChild(0).gameObject;
Item otherSlotItem = otherItemFromCharacterSystem.GetComponent <ItemOnObject>().item;
if (item.itemType == ItemType.UFPS_Weapon)
{
inventory.UnEquipItem1(otherItemFromCharacterSystem.GetComponent <ItemOnObject>().item);
inventory.EquiptItem(item);
}
else
{
inventory.EquiptItem(item);
if (item.itemType != ItemType.Backpack)
{
inventory.UnEquipItem1(otherItemFromCharacterSystem.GetComponent <ItemOnObject>().item);
}
}
if (this == null)
{
GameObject dropItem = (GameObject)Instantiate(otherSlotItem.itemModel);
dropItem.AddComponent <PickUpItem>();
dropItem.GetComponent <PickUpItem>().item = otherSlotItem;
dropItem.transform.localPosition = player.transform.localPosition;
inventory.OnUpdateItemList();
}
else
{
otherItemFromCharacterSystem.transform.SetParent(this.transform.parent);
otherItemFromCharacterSystem.GetComponent <RectTransform>().localPosition = Vector3.zero;
if (this.gameObject.transform.parent.parent.parent.GetComponent <Hotbar>() != null)
{
createDuplication(otherItemFromCharacterSystem);
}
this.gameObject.transform.SetParent(eS.transform.GetChild(1).GetChild(i));
this.gameObject.GetComponent <RectTransform>().localPosition = Vector3.zero;
}
gearable = true;
if (duplication != null)
{
Destroy(duplication.gameObject);
}
eS.gameObject.GetComponent <Inventory>().updateItemList();
inventory.OnUpdateItemList();
break;
}
}
}
}
}
}
if (!gearable && item.itemType != ItemType.UFPS_Ammo && item.itemType != ItemType.UFPS_Grenade)
{
Item itemFromDup = null;
if (duplication != null)
{
itemFromDup = duplication.GetComponent <ItemOnObject>().item;
}
inventory.ConsumeItem(item);
item.itemValue--;
if (itemFromDup != null)
{
duplication.GetComponent <ItemOnObject>().item.itemValue--;
if (itemFromDup.itemValue <= 0)
{
if (tooltip != null)
{
tooltip.deactivateTooltip();
}
inventory.deleteItemFromInventory(item);
Destroy(duplication.gameObject);
}
}
if (item.itemValue <= 0)
{
if (tooltip != null)
{
tooltip.deactivateTooltip();
}
inventory.deleteItemFromInventory(item);
Destroy(this.gameObject);
}
}
}
}
}
