private bool EquipDualUnequipOne(InventorySlotComponent from, InventorySlotComponent to)
    {
        var tmp = from.ItemComponent;

        from.ItemComponent = null;
        var availableInventorySpaces = new Queue <InventorySlotComponent>(GameObject.FindObjectsOfType <InventorySlotComponent>().Where(component => component.InventorySlotType == InventorySlotType.Inventory).Reverse().ToList());

        if (GetRightHand.ItemComponent != null && GetLeftHand.ItemComponent != null && availableInventorySpaces.Count < 2)
        {
            Debug.Log("Not enought inventory spaces!");
            from.ItemComponent = tmp;
            return(false);
        }

        if (GetRightHand.ItemComponent != null)
        {
            var rto = availableInventorySpaces.Dequeue();
            rto.ItemComponent = GetRightHand.ItemComponent;
            rto.ItemComponent.transform.position = rto.transform.position;
            GetRightHand.ItemComponent           = null;
        }
        if (GetLeftHand.ItemComponent != null)
        {
            var lto = availableInventorySpaces.Dequeue();
            lto.ItemComponent = GetLeftHand.ItemComponent;
            lto.ItemComponent.transform.position = lto.transform.position;
            GetLeftHand.ItemComponent            = null;
        }

        GetRightHand.ItemComponent = tmp;
        GetLeftHand.ItemComponent  = tmp;
        tmp.transform.position     = GetRightHand.transform.position;
        return(true);
    }
 private bool UnequipEquipment(InventorySlotComponent from, InventorySlotComponent to)
 {
     to.ItemComponent   = from.ItemComponent;
     from.ItemComponent = null;
     to.ItemComponent.transform.position = to.transform.position;
     return(true);
 }
        public void StartDragging(InventorySlotComponent slot)
        {
            if (IsDragging)
            {
                return;
            }
            _mouseCursorComponent.HasItemUnderTheCursor = true;

            _dragInventorySlot = slot;
            _dragItem          = _dragInventorySlot.CurrentItem;
            _dragInventorySlot.RemoveItem();
            transform.position = slot.gameObject.transform.position;
            _offset            = Camera.main.ScreenToWorldPoint(Input.mousePosition) - transform.position;

            if (_offset.Value.x >= _offsetClickValue)
            {
                _offset = new Vector2(_offsetDragValue, _offset.Value.y);
            }
            if (_offset.Value.x <= -_offsetClickValue)
            {
                _offset = new Vector2(-_offsetDragValue, _offset.Value.y);
            }
            if (_offset.Value.y >= _offsetClickValue)
            {
                _offset = new Vector2(_offset.Value.x, _offsetDragValue);
            }
            if (_offset.Value.y <= -_offsetClickValue)
            {
                _offset = new Vector2(_offset.Value.x, -_offsetDragValue);
            }

            _image.sprite  = slot.CurrentImage.sprite;
            _image.enabled = true;
            IsDragging     = true;
        }
 private bool EquipDualHand(InventorySlotComponent from, InventorySlotComponent to)
 {
     GetRightHand.ItemComponent = from.ItemComponent;
     GetLeftHand.ItemComponent  = from.ItemComponent;
     from.ItemComponent         = null;
     GetRightHand.ItemComponent.transform.position = GetRightHand.transform.position;
     return(true);
 }
    private bool EquipOneUnequipOne(InventorySlotComponent from, InventorySlotComponent to)
    {
        var tmp = from.ItemComponent;

        from.ItemComponent = to.ItemComponent;
        to.ItemComponent   = tmp;

        from.ItemComponent.transform.position = from.transform.position;
        to.ItemComponent.transform.position   = to.transform.position;
        return(true);
    }
        public void StopDragging()
        {
            (List <RaycastHit2D>, List <RaycastResult>)underTheMouse = _mouseCursorComponent.GetEveryObjectUnderTheMouse();

            InventorySlotComponent targetInventorySlot = underTheMouse.Item2.Where(e => e.gameObject.GetComponent <InventorySlotComponent>() != null)
                                                         .Select(e => e.gameObject.GetComponent <InventorySlotComponent>())
                                                         .FirstOrDefault();

            InteractableComponent playerInteractableComponent = GetCurrentInteractableComponentUnderTheMouseThatsCanEat(underTheMouse);

            // => CHANGE ITEM SLOT
            if (targetInventorySlot != null && targetInventorySlot.GetInstanceID() != _dragInventorySlot.GetInstanceID())
            {
                if (targetInventorySlot.CheckIfCanAcceptItem(_dragItem))
                {
                    targetInventorySlot.SetItem(_dragItem);
                }
                else
                {
                    _dragInventorySlot.SetItem(_dragItem);
                }
            }
            // => FEED THE PLAYER
            else if (playerInteractableComponent != null && _dragItem.Item.ItemType == ScriptableComponents.Item.EnumItemScriptableType.Flower)
            {
                _dragItem.Amount--;

                playerInteractableComponent.EatFlowerByDrag(new ItemDTO()
                {
                    Item = _dragItem.Item, Amount = 1
                });

                if (_dragItem.Amount > 0)
                {
                    _dragInventorySlot.SetItem(_dragItem);
                }
            }
            // => DROP ITEM
            else if (targetInventorySlot == null)
            {
                this.DropItem();
            }
            // => PUT ITEM ON THE SAME SPOT
            else
            {
                _dragInventorySlot.SetItem(_dragItem);
            }

            _image.enabled     = false;
            transform.position = _initialPosition;
            _dragInventorySlot = null;
            IsDragging         = false;
            _mouseCursorComponent.HasItemUnderTheCursor = false;
        }
    private bool EquipDualUnequipDual(InventorySlotComponent from, InventorySlotComponent to)
    {
        var tmp = from.ItemComponent;

        from.ItemComponent = to.ItemComponent;

        GetRightHand.ItemComponent = tmp;
        GetLeftHand.ItemComponent  = tmp;

        tmp.transform.position = GetRightHand.transform.position;
        return(true);
    }
示例#8
0
        public void AddItem(ItemDTO newItem)
        {
            InventorySlotComponent emptySlot = _slotList.FirstOrDefault(e => e.CheckIfCanAcceptItem(newItem));

            if (emptySlot == null)
            {
                Debug.LogError("Your inventory is full!");
                return;
            }

            emptySlot.SetItem(newItem);
        }
    private bool EquipItemUnequipItem(InventorySlotComponent from, InventorySlotComponent to)
    {
        if (from.ItemComponent.Item.ItemEquipmentType != to.ItemComponent.Item.ItemEquipmentType)
        {
            Debug.Log("Trying to mix types!");
            return(false);
        }

        var tmp = from.ItemComponent;

        from.ItemComponent = to.ItemComponent;
        to.ItemComponent   = tmp;

        from.ItemComponent.transform.position = from.transform.position;
        to.ItemComponent.transform.position   = to.transform.position;

        return(true);
    }
    public bool MoveItemInHands(InventorySlotComponent from, InventorySlotComponent to)
    {
        if (to.ItemComponent != null)   // We have something in the other hand
        {
            var tmp = to.ItemComponent;
            to.ItemComponent   = from.ItemComponent;
            from.ItemComponent = tmp;

            to.ItemComponent.transform.position   = to.transform.position;
            from.ItemComponent.transform.position = from.transform.position;
            return(true);
            // TODO: Update models
        }
        else    // We have something in one hand only
        {
            to.ItemComponent   = from.ItemComponent;
            from.ItemComponent = null;
            to.ItemComponent.transform.position = to.transform.position;
            return(true);
            // TODO: Update models
        }
    }
    // TODO: Split?

    public bool MoveItemInInventory(InventorySlotComponent from, InventorySlotComponent to)
    {
        if (to.ItemComponent != null)   // Swap two items
        {
            var tmp = from.ItemComponent;
            from.ItemComponent = to.ItemComponent;
            to.ItemComponent   = tmp;

            from.ItemComponent.transform.position = from.transform.position;
            to.ItemComponent.transform.position   = to.transform.position;
            // TODO: Update models
            return(true);
        }
        else    // Move item
        {
            to.ItemComponent   = from.ItemComponent;
            from.ItemComponent = null;
            to.ItemComponent.transform.position = to.transform.position;
            return(true);
            // TODO: Update models
        }
    }
    private bool EquipEquipment(InventorySlotComponent from, InventorySlotComponent to)
    {
        switch (from.ItemComponent.Item.ItemEquipmentType)
        {
        case ItemEquipmentType.Head:
            if (to.InventorySlotType != InventorySlotType.Head)
            {
                return(false);
            }
            break;

        case ItemEquipmentType.Body:
            if (to.InventorySlotType != InventorySlotType.Body)
            {
                return(false);
            }
            break;

        case ItemEquipmentType.Legs:
            if (to.InventorySlotType != InventorySlotType.Legs)
            {
                return(false);
            }
            break;

        default:
            Debug.Log("Cannot equip item!");
            return(false);
        }


        to.ItemComponent   = from.ItemComponent;
        from.ItemComponent = null;
        to.ItemComponent.transform.position = to.transform.position;
        return(true);
    }
    public bool MoveItem(InventorySlotComponent from, InventorySlotComponent to)
    {
        Debug.Log("BEGIN MOVE!");
        if (to.ItemComponent == null) // Move
        {
            Debug.Log("Move");
            if (from.InventorySlotType == InventorySlotType.Inventory)
            {
                Debug.Log("From Inventory");
                if (to.InventorySlotType == InventorySlotType.Inventory)
                {
                    Debug.Log("Moving item in inventory!");
                    // Move Items in inventory
                    return(MoveItemInInventory(from, to));
                }
                else
                {
                    Debug.Log("Equip item!");
                    // Equip item
                    if (from.ItemComponent.Item is HandItem &&
                        from.ItemComponent.Item.ItemEquipmentType == ItemEquipmentType.OneHand &&
                        (to.InventorySlotType == InventorySlotType.RightHand ||
                         to.InventorySlotType == InventorySlotType.LeftHand)) // Equip one-handed item
                    {
                        Debug.Log("Equip One Hand!");
                        return(EquipOneHand(from, to));
                    }
                    else if (from.ItemComponent.Item is HandItem &&
                             from.ItemComponent.Item.ItemEquipmentType == ItemEquipmentType.TwoHand &&
                             (to.InventorySlotType == InventorySlotType.RightHand ||
                              to.InventorySlotType == InventorySlotType.LeftHand)) // Equip two-handed item
                    {
                        Debug.Log("Equip Dual Hand!");

                        if (GetRightHand.ItemComponent != null || GetLeftHand.ItemComponent != null)
                        {
                            Debug.Log("Unequipping Other Hand And Equipping Dual Hand");
                            return(EquipDualUnequipOne(from, to));
                        }
                        else
                        {
                            Debug.Log("Equipping Dual Hand!");
                            return(EquipDualHand(from, to));
                        }
                    }
                    else if (from.ItemComponent.Item is EquippableItem && !(from.ItemComponent.Item is HandItem)
                             ) // Equip other item
                    {
                        Debug.Log("Equip Item");
                        return(EquipEquipment(from, to));
                    }
                    else // Do nothing
                    {
                        Debug.Log("Cannot equip item!");
                        return(false);
                    }
                }
            }
            else
            {
                Debug.Log("From Equipped");
                if (to.InventorySlotType == InventorySlotType.Inventory)
                {
                    Debug.Log("Unequipping item!");
                    // Unequip item
                    if (from.ItemComponent.Item is HandItem &&
                        from.ItemComponent.Item.ItemEquipmentType == ItemEquipmentType.OneHand &&
                        (from.InventorySlotType == InventorySlotType.RightHand ||
                         from.InventorySlotType == InventorySlotType.LeftHand)) // Unequip hand
                    {
                        Debug.Log("Unequipping One Hand");
                        return(UnequipOneHand(from, to));
                    }
                    else if (from.ItemComponent.Item is HandItem &&
                             from.ItemComponent.Item.ItemEquipmentType == ItemEquipmentType.TwoHand &&
                             (from.InventorySlotType == InventorySlotType.RightHand ||
                              from.InventorySlotType == InventorySlotType.LeftHand)) // Unequip borg hands
                    {
                        Debug.Log("Unequiping Two Hands");
                        return(UnequipDualHand(from, to));
                    }
                    else if (from.ItemComponent.Item is EquippableItem && !(from.ItemComponent.Item is HandItem)
                             ) // Unequip item
                    {
                        Debug.Log("Unequipping Item");
                        return(UnequipEquipment(from, to));
                    }
                    else
                    {
                        Debug.Log("Cannot unequip item");
                        return(false);
                    }
                }
                else
                {
                    Debug.Log("Swithing Hand");
                    // Switch hand
                    if (from.InventorySlotType == InventorySlotType.RightHand &&
                        to.InventorySlotType == InventorySlotType.LeftHand ||
                        to.InventorySlotType == InventorySlotType.RightHand &&
                        from.InventorySlotType == InventorySlotType.LeftHand)
                    {
                        Debug.Log("Swap Hand");
                        return(MoveItemInHands(from, to));
                    }
                    else
                    {
                        Debug.Log("Cannot swap items!");
                    }
                }
            }
        }
        else // Swap
        {
            Debug.Log("Swap");
            if (from.InventorySlotType == InventorySlotType.Inventory)
            {
                Debug.Log("From Inventory");
                if (to.InventorySlotType == InventorySlotType.Inventory)
                {
                    Debug.Log("Swap Items In Inventory");
                    // Swap items in inventory
                    return(MoveItemInInventory(from, to));
                }
                else
                {
                    Debug.Log("Swapping Inventory With Equipped Item");
                    // Swap with equipped item
                    if (from.ItemComponent.Item is HandItem &&
                        from.ItemComponent.Item.ItemEquipmentType == ItemEquipmentType.OneHand &&
                        (to.InventorySlotType == InventorySlotType.RightHand ||
                         to.InventorySlotType == InventorySlotType.LeftHand)) // Equip one-handed item
                    {
                        Debug.Log("Swapping Inventory One Hand");
                        if (to.ItemComponent.Item.ItemEquipmentType == ItemEquipmentType.TwoHand)
                        {
                            Debug.Log("Swapping With Two Hand");
                            return(EquipOneUnequipDual(from, to));
                        }
                        else
                        {
                            Debug.Log("Swapping With One Hand");
                            return(EquipOneUnequipOne(from, to));
                        }
                    }
                    else if (from.ItemComponent.Item is HandItem &&
                             from.ItemComponent.Item.ItemEquipmentType == ItemEquipmentType.TwoHand &&
                             (to.InventorySlotType == InventorySlotType.RightHand ||
                              to.InventorySlotType == InventorySlotType.LeftHand)) // Equip two-handed item
                    {
                        Debug.Log("Swapping Inventory Two Hand");
                        if (to.ItemComponent.Item.ItemEquipmentType == ItemEquipmentType.TwoHand)
                        {
                            Debug.Log("Swapping With Two Hand");
                            return(EquipDualUnequipDual(from, to));
                        }
                        else
                        {
                            Debug.Log("Swapping With One Hand");
                            return(EquipDualUnequipOne(from, to));
                        }
                    }
                    else if (from.ItemComponent.Item is EquippableItem && !(from.ItemComponent.Item is HandItem)
                             ) // Equip other item
                    {
                        Debug.Log("Swapping Equipment With Equipment");
                        return(EquipItemUnequipItem(from, to));
                    }
                    else // Do nothing
                    {
                        Debug.Log("Cannot equip item!");
                        return(false);
                    }
                }
            }
            else
            {
                Debug.Log("From Equipment");
                if (to.InventorySlotType == InventorySlotType.Inventory)
                {
                    Debug.Log("To Inventory");
                    // Swap with item in inventory
                    // Unequip item
                    if (from.ItemComponent.Item is HandItem &&
                        from.ItemComponent.Item.ItemEquipmentType == ItemEquipmentType.OneHand &&
                        (from.InventorySlotType == InventorySlotType.RightHand ||
                         from.InventorySlotType == InventorySlotType.LeftHand)) // Unequip hand
                    {
                        Debug.Log("Unequip One Hand");
                        if (to.ItemComponent.Item.ItemEquipmentType == ItemEquipmentType.TwoHand)
                        {
                            Debug.Log("Equip Two Hand");
                            return(EquipDualUnequipOne(to, from));
                        }
                        else
                        {
                            Debug.Log("Equip One Hand");
                            return(EquipOneUnequipOne(to, from));
                        }
                    }
                    else if (from.ItemComponent.Item is HandItem &&
                             from.ItemComponent.Item.ItemEquipmentType == ItemEquipmentType.TwoHand &&
                             (from.InventorySlotType == InventorySlotType.RightHand ||
                              from.InventorySlotType == InventorySlotType.LeftHand)) // Unequip borg hands
                    {
                        Debug.Log("Unequip Dual Hand");
                        if (to.ItemComponent.Item.ItemEquipmentType == ItemEquipmentType.TwoHand)
                        {
                            Debug.Log("Equip Dual Hand");
                            return(EquipDualUnequipDual(to, from));
                        }
                        else
                        {
                            Debug.Log("Equip One Hand");
                            return(EquipOneUnequipDual(to, from));
                        }
                    }
                    else if (from.ItemComponent.Item is EquippableItem && !(from.ItemComponent.Item is HandItem)
                             ) // Unequip item
                    {
                        Debug.Log("Unequip Equipment, Equip Other");
                        return(EquipItemUnequipItem(to, from));
                    }
                    else
                    {
                        Debug.Log("Cannot unequip item");
                        return(false);
                    }
                }
                else
                {
                    // Swap items in hand
                    Debug.Log("Swap items in hand!");
                    return(MoveItemInHands(from, to));
                }
            }
        }

        Debug.Log("Some other non-permitted movement happened!");
        return(false);
    }
示例#14
0
 protected override void SetInitialValues()
 {
     IsSelected = false;
     _image     = this.GetComponent <Image>();
     _inventorySlotComponent = this.GetComponent <InventorySlotComponent>();
 }
示例#15
0
        private void ManageMouseUniqueLeftClick()
        {
            if (_inputManager.MouseLeftButton == 1 && !_leftButtomPressed)
            {
                _leftButtomPressed = true;
                _audioComponent.PlayAudio("click");

                List <IInteractable>   interactableList        = new List <IInteractable>();
                List <Button>          buttonList              = new List <Button>();
                List <IPlayer>         playersList             = new List <IPlayer>();
                InventorySlotComponent _inventorySlotComponent = null;

                bool hitSomeUIComponent = false;
                _canMove = true;

                Vector2 mousePosition = this.ManageMouseClick((hitUI) =>
                {
                    hitSomeUIComponent = true;
                    if (_inventorySlotComponent is null)
                    {
                        _inventorySlotComponent = hitUI.gameObject.GetComponent <InventorySlotComponent>();
                    }
                },
                                                              (hit) =>
                {
                    buttonList.AddRange(hit.collider.gameObject.GetComponents <Button>());
                    interactableList.AddRange(hit.collider.gameObject.GetComponents <IInteractable>().Where(e => e.PlayerInteractWith).ToList());
                    playersList.AddRange(hit.collider.gameObject.GetComponents <IPlayer>().ToList());
                });
                // => UI INTERACTIONS
                if (_inventorySlotComponent != null)
                {
                    _inventorySlotComponent.StartInteraction();
                }

                if (hitSomeUIComponent)
                {
                    return;
                }

                // => NORMAL INTERACTIONS
                IInteractable interactableChoice = interactableList.OrderBy(e => e.Order()).FirstOrDefault();

                if (playersList.Any() && interactableChoice is IDamageTaker)
                {
                    interactableChoice = interactableList.Where(e => !(e is IDamageTaker)).OrderBy(e => e.Order()).FirstOrDefault();
                }

                if (interactableChoice is IDamageTaker damagable)
                {
                    DamageDealerComponent damageDealerComponent = _playerStateManager.GetActivePlayerStructure().GetDamageDealerComponent();

                    if (damageDealerComponent is null)
                    {
                        return;
                    }

                    damagable.StartCombat(damageDealerComponent);
                }

                if (interactableChoice is IPickable pickable)
                {
                    pickable.PickUp();
                }

                if (interactableChoice is IPlantable plantable)
                {
                    plantable.Interact();
                }
            }
            else if (_inputManager.MouseLeftButton == 0 && _leftButtomPressed)
            {
                _leftButtomPressed = false;
            }
        }